Question sur un cours (besoin d'explications)

[humanite]

Bonjour,

je souhaiterais que quelqu'un puisse m'expliquer pourquoi, dans un cours où il est question de pointeur, il est dit :

1) Si on a un par exemple un grand nombre de variables de type int, et qu'il s'avère soudain que pour une raison quelconque, je souhaite ajouter 1 à 9697 d'entre elles, pourquoi est-il moins fatiguant d'utiliser un pointeur dont on sait qu'il s'agit d'ailleurs d'une seule variable(donc elle peut prendre des valeurs différentes) à la place de passer variable par variable ? En quoi est-ce moins coûteux ?

2) Et surtout, pourquoi si le nombre de données à traiter est inconnu au moment de l'écriture du programme, alors pourquoi la première technique utilisant le nom des variables (et pas un pointeur) est inapplicable ?

3) Pourriez-vous me donner un exemple pour ce 2), car je ne vois pas ce que l'on entend par ce 2) ?

merci d'avance de vos explications détaillées.

Cordialement

[Ehonn]

Je ne pense pas avoir compris...
Mais je ne vois pas la difficulté ou le souci de ce code ou l'utilisateur ne manipule pas de pointeur :p

Code :

1
2
std::vector<int> v(9697);
for (int & e : v) { ++e; }

Peut-être que les questions essayent de faire parler des tableaux; mais un tableau n'est pas un pointeur, et ce n'est pas du C++ et encore moins du C++ de débutant.

PS: As-tu un lien sur ce cours ou pourrais-tu préciser (plus) le contexte ?

[Lintel-oo]

Ton cours il était en C ou C++ ? Car ça change tout ^^ (enfin pour cette explication)

2) Et surtout, pourquoi si le nombre de données à traiter est inconnu au moment de l'écriture du programme, alors pourquoi la première technique utilisant le nom des variables (et pas un pointeur) est inapplicable ?

Je ne sais pas si j'ai très bien compris la formulation de la question mais je vais essayer de partir d'un exemple.

Imagine tu as un parc de voitures identifiées par un int (exemple vraiment pourri mais je ne sais pas pourquoi c'est le premier truc qui m'est venu à l'esprit).
Tu peux déclarer

Code :

int voiture1, voiture2, ... voiture1000

C'est long. Pour simplifier tu peux déjà déclarer un tableau de voiture :

Code :

1
2
3
4
5
int voitures[1000];
//puis
voitures[0] = ...;
...
voitures[999] = ...;

Maintenant imagine tu veux ajouter une voiture à ton parc.
Dans ce cas, et dans la situation présente, tu ne peux pas ! En effet tu n'as pas le droit d'accéder à la case 1000 ou plus du tableau voitures sinon tu vas avoir droit à un segment fault. Comment faire alors ?
Eh bien les pointeurs permettent de résoudre la solution :

Code :

1
2
 
int *voitures = (int*)malloc(1000*sizeof(int));

La tu déclares un "parc" de 1000 valeurs de type int.
Ainsi lorsque tu voudras ajouter une voiture tu pourras réallouer l'espace mémoire pour qu'il puisse accueillir une voiture de plus avec realloc :

Code :

1
2
3
 
voitures = (int*)realloc(1001*sizeof(int));
voitures[1000] = ...;

Bon évidemment ce que je fais là est nul est sale, donc c'est pas vraiment un bon exemple, surtout qu'il ne faut pas oublier de libérer la mémoire avec free sinon t'auras des pertes de mémoire !

Je viens d'avoir un exemple un peu meilleur, toujours avec un parc de voitures . Imagine tu veux que l'utilisateur entre le nombre de voitures de ton parc (avec scanf par exemple bien que ce soit mal d'utiliser scanf).
Tu fais comment maintenant que l'utilisateur a rentré le nombre de voitures pour les créer, ces voitures ?
Là tu es obligé de passer par l'allocation dynamique, les pointeurs :

Code :

1
2
scanf("%d",nombreDeVoitures);
voitures = (int*)malloc(nombreDeVoitures*sizeof(int));

Et là tu as bien un parc constitué du nombre de voitures entré par l'utilisateur, si tu y réfléchis bien tu n'aurais pas pu faire autrement pour avoir pile le bon nombre.

Enfin il ne faut pas oublier de libérer la mémoire allouée, avec free :

Code :

free(voitures);

Voilà j'espère t'avoir un peu éclairé

EDIT : Zut on est dans le forum C++ autant pour moi j'ai écris des choses absurdes avec malloc et free alors qu'il faut le faire avec new et delete mais je modifierai cela demain.

[Ehonn]

Envoyé par Lintel-oo

EDIT : Zut on est dans le forum C++ autant pour moi j'ai écris des choses absurdes avec malloc et free alors qu'il faut le faire avec new et delete mais je modifierai cela demain.[/SIZE]

C'est (sûrement) la réponse attendu aux questions...
Et non, on n'utilise pas new et delete en C++ dans ce cas, mais std::vector<T> :O

[humanite]

Bonsoir, pour répondre à une des questions posées, c'est du C++. Par ailleurs, ceci se trouve sur le fichier joint suivant (que j'ai mis en pièce jointe), fin page 5/11 puis début page 6/11 (sur une vingtaine de lignes).

Par ailleurs, à priori, la question n'essaye pas forcément de faire parler un tableau. C'est plutôt général.

En souhaitant que cela vous aide à me faire comprendre les choses avec des exemples parlant.

Merci

ps:j'ai vu qu'il y avait aussi un doute sur malloc et free (à la place de new et delete)

[bretus]

Bonsoir,

L'allocation dynamique en C passe par malloc/free. En C++, elle passe par new/delete.

Je te conseillerais bien de lire ce cours sur les pointeurs et les références, il vaudra les grands discours.

[Ehonn]

À priori la leçon 1 parle du concept de la variable.
Cette leçon (la deuxième) par des types de base et des classes (sans méthodes).

À part le type bool et la rapide allusion à la possibilité de rajouté des fonctions à une classe, c'est du C.

Ce cours introduit beaucoup trop rapidement les pointeurs.
Et donc, le pointeurs arrivent avant:
- les chaînes de caractères (string)
- int main() { return 0; }- if else, for, while, do while- les fonctions
- les références
puisque tout ça n'apparaît pas dans ce cours (peut-être dans la leçon 1 ?)

Sinon (extrait de la leçon):

Maintenant, si vous avez déjà un peu pratiqué la programmation à l'aide d'un autre langage, vous pensez sans doute que le cas des 9 697 données de type double peut être traité très facilement, à l'aide d'un tableau que l'on parcourt en faisant varier un index.

Oui (ou même sans comme dans mon premier message).

Deux remarques s'imposent alors. La première est que le tableau n'est qu'un cas particulier : il arrive que l'organisation "naturelle" des données à traiter ne soit, justement, pas un tableau. Il peut s'agir d'une liste chaînée (Leçon 10) ou d'un arbre (Leçon 19), par exemple. L'usage de pointeurs offre une réponse générale à ce problème, alors qu'un index ne permet de traiter qu'une seule structure de données, le tableau.

En C++ on parle d'itérateur.

La deuxième remarque est que, lorsqu'une organisation de type tableau convient, l'usage d'un pointeur ne donne pas lieu à une écriture très différente de celle adoptée lorsqu'on utilise un tableau (nous verrons dès la Leçon 9 que, lorsqu'on lit un programme, l'examen des instructions manipulant les données ne permet pas de déterminer s'il y a un véritable tableau ou s'il s'agit d'un simple pointeur)

Un std::vector peut nous donner plus d'informations qu'un simple pointeur.
std::sort utilise des RandomAccessIterator et ne peut donc pas s'utiliser avec std::list.
Ce n'est pas la bonne façon de penser en C++, pour faire ce genre de chose, on utilise la programmation générique.

--- --- ---

C++ est un langage de haut niveau qui permet de faire des beaucoup de choses simplement.
De part son héritage au C et sa devise "on ne paye pas pour ce qu'on utilise pas", il permet aussi de travailler de façon très proche avec la machine. Mais ce n'est surtout pas ce qu'il faut montrer dans un cours de C++ pour débutants.

Les pointeurs n'offre "aucune" sécurité et sont aussi compliqués que dangereux à manipuler.

C++ les a "remplacés" ou "masqués" par des concepts plus avancés et aussi performants et surtout, plus fiables.

[Théo0303]

Bonjour,
Peut-être pourrais-je t'aider avec mes réponses.
Avant tout il ne faut pas voir une variable comme étant tout simplement une valeur. Mais plutôt comme étant une adresse mémoire et une valeur.
D'habitude le développeur ne s'occupe pas de cette adresse mémoire, mais souvent de la valeur de cette variable.
Pour le 1)
L'avantage est d'abord algorithmique à mon avis. Si tu as 9697 variables à modifier il y a de fortes chances que tu retapes du code pour les modifier , tandis qu'en utilisant un pointeur, tu peux par exemple garder la même boucle et juste changer la valeur de ton pointeur (qui contient l'adresse mémoire de la variable à modifier).

Pour le 2) et le 3)
Je pense qu'on entends par là que l'adresse de la variable existe toujours à partir du moment que la variable existe. Tu peux ne pas connaître le nom mais si tu connais l'adresse tu peux effectuer tes opérations sur la variable en question. En gros, Il faut garder en mémoire que la valeur d'un pointeur est toujours du même type, tu n'a qu'a faire ton algo en n'utilisant que le pointeur dont tu connais déjà le type et le nom.

J'espère voir pu t'aider.
Théo

[humanite]

Fort des renseignements supplémentaires que j'ai ajoutés ainsi que du fichier joint, quelqu'un pourrait-il tenter de répondre avec des exemples sûrs à mes 3 questions afin que je puisse bien comprendre?


D'avance merci.

[Lintel-oo]

Je ne saurais que trop te conseiller un apprentissage du C ne serait-ce que pour avoir des "bases" en allocation dynamique après tu peux toujours commencer par du C++ mais si tu n'est pas à l'aise avec la base ça risque d'être compliqué pour aborder les nombreux concepts de ce langage

[humanite]

théo0303, s'il vous plaît, pouvez-vous préciser ce que vous disiez pour 1) ,2), 3) par des exemples ?

merci

[Ehonn]

Envoyé par Lintel-oo

Je ne saurais que trop te conseiller un apprentissage du C ne serait-ce que pour avoir des "bases" en allocation dynamique après tu peux toujours commencer par du C++ mais si tu n'est pas à l'aise avec la base ça risque d'être compliqué pour aborder les nombreux concepts de ce langage

Non, C++ != C.
De plus, pour le point spécifique de l'allocation dynamique, l'usage et la syntaxe diffère du C. Quel en est donc l'intérêt (?)

--- --- ---

Les codes n'ont pas été testés.

--- --- ---

En C.

J'ai ce tableau

Code :

int * tab_int = malloc(9697 * sizeof(int));

et ce tableau

Code :

double * tab_double = malloc(9697 * sizeof(double));

Si je veux ajouter 1 à tous les éléments des deux tableaux avec une fonction commune. Je ne peux pas (?) car sizeof(int) est différente de sizeof(double).

Pour les tableaux de int (il faut tout re-écrire pour les double...):

Code :

1
2
3
4
5
6
7
8
void add_1_tab_int(int * first, int * const last)
{
    while (first != last)
    {
        ++(*first);
        ++first;
    }
}

On est relativement loin de:

Code :

for (size_t i = 0; i < N; ++i) { ++tab_int[i]; }

(Alors que le cours dit qu'il n'y a que peu de différence...)

Avec une autre structure: une liste (la fin est marquée par le pointeur NULL)

Code :

1
2
3
4
5
struct list_int
{
    int val;
    int * next;
};

Le code est relativement proche mais il faut encore le ré-écrire:

Code :

1
2
3
4
5
6
7
8
void add_1_list_int(int * first)
{
    while (first != NULL)
    {
        ++(first->val);
        first->next;
    }
}

Avec un boucle for (discutable)

Code :

for (list_int * p = une_list_int; p ! NULL; ++p) { ++(p->val); }

Peut-être que je m'y prend mal. Mais ce n'est ni simple ni réutilisable (il faut faire au minimum un copier coller :s).
Et c'est surtout la très mauvaise façon de fair en C++.

--- --- ---

En C++

On écrit une fonction générique qui attend des paramètres avec certaines propriétés.
- l'opérateur ++ permet de passer à l'élément suivant
- l'opérateur * permet d'obtenir la valeur
(ces propriétés sont dans (tous) les itérateurs des conteneurs standard de C++)

Code :

1
2
3
4
5
template <class input_iterator>
void add_1(input_iterator first, input_iterator const & last)
{
   for (; first != last; ++first) { ++(*first); }
}

Et là cette fonction est utilisable avec les tableaux, les std::vector, les std::list...
Mais ce n'est pas grâce aux pointeurs. C'est possible par les propriétés commune des itérateurs et la programmation générique.

Appels possibles :

Code :

1
2
std::vector<int> v;
add_1(v.begin(), v.end());

Code :

1
2
std::vector<double> v;
add_1(v.begin()+1, v.begin()+5);

Code :

1
2
std::list<float> l;
add_1(l.begin(), l.end());

Code :

1
2
unsigned int [42] t;
add_1(t, t + 42);

[Lintel-oo]

Non, C++ != C.
De plus, pour le point spécifique de l'allocation dynamique, l'usage et la syntaxe diffère du C. Quel en est donc l'intérêt (?)

Je sais bien que ce n'est absolument pas la même chose.
Cependant quel est l’intérêt de commencer la programmation (puisque c'est visiblement le cas) avec un langage aussi difficile pour qui n'a jamais entendu un mot de programmation orientée objet ?

C'est pour ça qu'il serait plus enrichissant de commencer avec un langage plus "facile" bien qu'il soit évidemment possible de commencer par le C++ mais sans bases c'est d'autant plus difficile que tout doit (enfin devrait) être pensé dans la "philosophie" du C++, et même ce que tu lui proposes, je pense, est déjà trop compliqué, puisque cela fait appel à des notions d'itérateur, c'est pour ça dans un premier temps qu'utiliser new et delete est nécessaire et même ça l'est encore lorsqu'on utilise les vector et autres objets de la stl.


@matlab_ : Sinon pour les 3 questions pour la première je dirais précise le contexte : c'est fatiguant pour le programmeur, pour le compilateur (en gros ça prend plus de temps à traiter) ? Pour ce qui est du programmeur, comme le dit ehonn tu peux utiliser des vectors mais admettons que tu ne connaisses pas ces objets, alors dans ce cas on peut dire qu'effectivement si le programmeur déclares 10000 variables au début de son programme, déjà c'est très moyen et d'autre part s'amuser à incrémenter chaque variable une par une est d'une bêtise saisissante En tout cas dans ce cas oui les pointeurs permettent de moins se fatiguer mais bon généralement tu n'as pas à déclarer 10000 variables.

Pour la deuxième et troisième question, j'ai répondu dans mon premier post, même si c'est du C, tu peux facilement l'appliquer en C++ si tu remplaces les malloc par des new et les free par les delete (bien que ça ne s'écrive pas exactement de la même manière c'est quand même très similaire).

[gbdivers]

Je sais bien que ce n'est absolument pas la même chose.
Cependant quel est l’intérêt de commencer la programmation (puisque c'est visiblement le cas) avec un langage aussi difficile pour qui n'a jamais entendu un mot de programmation orientée objet ?

C'est pour ça qu'il serait plus enrichissant de commencer avec un langage plus "facile" bien qu'il soit évidemment possible de commencer par le C++ mais sans bases c'est d'autant plus difficile que tout doit (enfin devrait) être pensé dans la "philosophie" du C++, et même ce que tu lui proposes, je pense, est déjà trop compliqué, puisque cela fait appel à des notions d'itérateur, c'est pour ça dans un premier temps qu'utiliser new et delete est nécessaire et même ça l'est encore lorsqu'on utilise les vector et autres objets de la stl.

Il va falloir (ou pas, c'est un question qui a été abordé 1000 fois déjà) expliquer pourquoi le C est plus "simple" que le C++ à apprendre. Tu trouves que le malloc (avec un cast, ne pas oublier de multiplier par sizeof, ne pas oublier le free, quand appeler le free, savoir s'il faut utiliser malloc, calloc ou realloc, etc) est plus simple qu'un vector qui gère la mémoire lui même ?

Le C++ permet de se focaliser sur le problème à résoudre au lieu de perdre du temps sur les détails de gestion de mémoire. De plus, il offre des concepts haut niveau (ie proche de l'intuition normal) qui sont facilement compréhensible (n'importe quel débutant peut comprendre des notions comme "créer un tableau de N éléments", "accéder à l'élément i du tableau", "augmenter la taille du tableau à M éléments", etc).
C'est justement l'approche historique de l’apprentissage du C++ (ie mélange de C et de C++) qui fait croire que le C++ est compliqué

[Ehonn]

Envoyé par Lintel-oo

Cependant quel est l’intérêt de commencer la programmation (puisque c'est visiblement le cas) avec un langage aussi difficile pour qui n'a jamais entendu un mot de programmation orientée objet ?

Il y a une différence entre concevoir une classe et utiliser celles qui existent.
Ceci est plus simple

Code :

std::vector<int> tab;

Que ceci:

Code :

1
2
int * tab = new int [N];
delete [] tab;

L'allocation dynamique "nue" est compliquée et "peu utile" en C++.

Envoyé par Lintel-oo

C'est pour ça qu'il serait plus enrichissant de commencer avec un langage plus "facile" bien qu'il soit évidemment possible de commencer par le C++ mais sans bases c'est d'autant plus difficile que tout doit (enfin devrait) être pensé dans la "philosophie" du C++, et même ce que tu lui proposes, je pense, est déjà trop compliqué, puisque cela fait appel à des notions d'itérateur, c'est pour ça dans un premier temps qu'utiliser new et delete est nécessaire et même ça l'est encore lorsqu'on utilise les vector et autres objets de la stl.

Qu'elles sont les bases de C++ pour toi ?
En tout cas il n'est pas nécessaire de connaître les pointeurs pour utiliser les algos de la bibliothèque standard.
(Je n'ai jamais dit que c'était simple, mais que c'était la bonne façon de faire. De plus, c'est plus simple que les pointeurs.)

Envoyé par Lintel-oo

comme le dit ehonn tu peux utiliser des vectors

tu peux tu dois.

Envoyé par Lintel-oo

effectivement si le programmeur déclares 10000 variables au début de son programme, déjà c'est très moyen et d'autre part s'amuser à incrémenter chaque variable une par une est d'une bêtise saisissante En tout cas dans ce cas oui les pointeurs permettent de moins se fatiguer mais bon généralement tu n'as pas à déclarer 10000 variables.

Ce sont les tableaux qui permettent ceci, les pointeurs ne sont qu'une façon (sale (dans ce cas)) de les parcourir.

Envoyé par Lintel-oo

Pour la deuxième et troisième question, j'ai répondu dans mon premier post, même si c'est du C, tu peux facilement l'appliquer en C++ si tu remplaces les malloc par des new et les free par les delete (bien que ça ne s'écrive pas exactement de la même manière c'est quand même très similaire).

Ça va compiler et potentiellement faire ce que tu veux mais en utilisant une façon compliquée et source d'erreurs (edit: comme le dit gbdivers ).

[Lintel-oo]

tu peuxtu dois.

Ici tu peux aussi utiliser les listes, quand on a pas besoin d'accéder à un élément précis particulier c'est plus rapide enfin bon je pense que tu es déjà au courant après c'est du détail

L'allocation dynamique "nue" est compliquée et "peu utile" en C++.

Je sais pas si tu considère les pointeurs intelligents dans l'allocation dynamique "nue" si c'est le cas je ne suis pas d'accord enfin je pense que tu les comptes à part en tout cas utiliser des pointeurs intelligents au début n'est sans doute pas très utile.

Et je persiste à dire que quand même savoir utiliser la mémoire correctement avec new et delete c'est super utile surtout au début ne serait-ce que pour comprendre le principe même de pointeur.
Lorsqu'on te présente un vector quand tu débutes cela m'étonnerait que tu comprennes le principe même d'allocation dynamique.

[gbdivers]

que tu comprennes le principe même d'allocation dynamique.

Effectivement, en relisant la question initiale, l'utilisation de vector, qui permet de masquer les détails de gestion de mémoire, n'aidera pas à comprendre les pointeurs.

Nos remarques s'appliquent dans le cas général de l'apprentissage du C++
Et l'expérience montre que les débutants se perdent généralement dans les détails bas niveau, qu'ils ne réalisent pas que dans 99% des cas la gestion manuelle est une mauvaise approche, qu'ils n'apprennent pas du coup les fonctionnalités plus "haut niveau" du C++ qui permet d'écrire du code plus sur, plus maintenable, plus évolutif, etc. Au final, il font du C with class

[Ehonn]

Envoyé par Lintel-oo

Ici tu peux aussi utiliser les listes, quand on a pas besoin d'accéder à un élément précis particulier c'est plus rapide enfin bon je pense que tu es déjà au courant après c'est du détail

Oui pour l'utilisation de liste, faux pour la rapidité.
Les parcours de vecteurs sont plus rapides que les ceux des listes car l'empreinte mémoire est moindre et l'organisation des données est forcément linéaire donc il y a moins de défaut de cache.
Seules les opérations d'ajout et de suppression sont plus rapides pour les listes. Et ce n'est pas vrai s'il n'y a pas beaucoup d'éléments.
Tu trouveras une facilement vidéo avec les mots clefs «Bjarne Stroustrup - C++11 Style - Going Native (2012.02.02)»; vers le milieu de la vidéo le sujet est «Vector vs. List»

Envoyé par Lintel-oo

Je sais pas si tu considère les pointeurs intelligents dans l'allocation dynamique "nue" si c'est le cas je ne suis pas d'accord enfin je pense que tu les comptes à part en tout cas utiliser des pointeurs intelligents au début n'est sans doute pas très utile.

Je ne considère pas les pointeurs intelligents comme de l'allocation dynamique nue.
Non ce n'est pas très utile au même titre que les pointeurs, ça répond aux rares cas où l'allocation dynamique est nécessaire. (La syntaxe est plus simple et il n'y a pas besoin de s'occuper de l'appel à delete).

Envoyé par Lintel-oo

Et je persiste à dire que quand même savoir utiliser la mémoire correctement avec new et delete c'est super utile surtout au début ne serait-ce que pour comprendre le principe même de pointeur.
Lorsqu'on te présente un vector quand tu débutes cela m'étonnerait que tu comprennes le principe même d'allocation dynamique.

Pourquoi vouloir se compliquer la tâche avec new et delete ?
En quoi new et delete permettent de comprendre ce qu'est une adresse mémoire ?
Pourquoi as-tu besoin de comprendre l'allocation dynamique (lorsque tu débutes, et même après) ?
De façon plus générale, dans quels cas utilises-tu new et delete ? dans quels cas utilises-tu des pointeurs nus ?