Point ou flèche ?

Bonjour,

je débute en C++ et j'aimerai juste savoir la différence entre, par exemple:
Code:

1 2 3 4 5 std::vector<Objet> listeObjet; Objet objet; objet.setNom("test"); listeObjet.push_back(objet);
et
Code:

1 2 3 4 5 std::vector<Objet> listeObjet; Objet *pointeurSurObjet = new Objet(); pointeurSurObjet ->setNom("test"); listeObjet.push_back(*pointeurSurObjet );
Je vois pas trop, dans le premier exemple c'est comme en gros si on ajoutait une structure en C dans une liste et dans le second cas alors c'est un pointeur sur une structure ? Mais dans le second cas on ne peux pas ajouter l'adresse de cette structure dans la liste, on met une * pour ajouter que sa valeur ? De plus comme on ajoute sa valeur on n'est pas obligé de parcourir la liste pour faire des "delete" sur les objets pointés ?

Merci beaucoup !

C'est ce qu'on appelle un pointeur et déférencement. :weird:
Et ton vector contient des objets, push_back ajoute une copie de l'objet. Ton 2° code est surtout source de leak et ne devrait pas être écrit.

Salut,

Déjà, de manière générale, les mutateur (setXXX, comme ton setNom), c'est à éviter autant que possible, car c'est souvent le symptome du fait que tu penses à tes classes en fonction des données qu'elles contiennent au lieu d'y penser en termes de services attendus de leur part.

De plus, le nom de (quoi que ce soit) va souvent servir (seul ou accompagné d'autre donnée) d'"identifiant unique" pour chaque instance particulière de tes classes, si bien que la modification du nom d'une instance particulière risque très fort d'avoir un impact particulièrement négatif sur le reste de ton programme.

Du coup, il est donc très largement préférable de le définir une bonne fois pour toute (au travers du constructeur de ta classe) et ... de ne pas permettre à l'utilisateur de ta classe d'aller le modifier par la suite ;)

Ensuite, ton deuxième code est, purement et simplement faux!!! Il y a deux raisons à cela :

Il occasionne une fuite mémoire, car, dés que tu vas sortir de la fonction qui contient se code, tu vas perdre l'adresse mémoire représentée par pointeurSurObjet, et tu ne pourras donc plus libérer la mémoire qui a été allouée à ce pointer. Si cela se reproduit trop souvent, c'est la stabilité de tout le système (l'ordinateur, le serveur sur lequel s'exécute l'application) qui sera mise en péril!
De manière générale, on n'utilise l'allocation dynamique de la mémoire (que l'on préférera faire au travers de pointeurs intelligents) uniquement pour les classes qui ont sémantique d'entité, et ces classe sont -- par nature -- non copiable, or, ce code occasionne une copie de l'élément pointé par pointeurSurObjet, ce qui est contradictoire

Enfin, pour quand même répondre à ta question... De toute évidence, tu as tété à la mamelle du java avant de t'intéresser au C++. A titre perso, j'aurais préféré l'inverse, mais bon...

Si je ne m suis pas trompé et que tu viens de java (ou de C#), il faut savoir qu'il y a trois différences fondamentales entre C++ et ces deux langages :

Contrairement à java et à C#, C++ n'a pas de "ramasse miette" (garbage collector)et,
contrairement à ces deux langages, lorsque tu utilise le mot clé class en C++, il n'y a pas d'héritage implicite avec une quelconque classe Object.x
alors que tu manipule systématiquement des référence en java, C++ te permet de manipuler des valeurs, des références et des pointeurs (par défaut, on manipule des valeurs ;) )

En fait, si on est obligé d'utiliser un code proche de MyObject obj = new MyObject; en java, c'est pour que la machine virtuelle puisse "enregistrer" obj au niveau du garbage collector, et c'est ce qui nécessite une relation d'héritage avec cette fameuse classe Object.

En C++, comme il n'y a pas de garbage collector, il n'y a aucune raison d'avoir un héritage implicite avec une quelconque classe Object, et c'est d'autant plus vrai que la philosophie du C++ est pay only for what you use (ne payez que pour ce que vous utilisez).

En C++, on manipule des valeurs par défaut, alors que l'on manipule (implicitement) des référence ne java. Mais, si on ne veut pas manipuler des valeurs, on préféra utiliser des références plutôt que des pointeurs (pour le passage d'argument à une fonction, par exemple), car les référence présente une garantie que le pointeur ne fourni pas : l'objet référencé par une référence doit obligatoirement exister lors de la création d'une référence, alors qu'un pointeur peut pointer sur une adresse connue comme "ne pointant sur aucun élément valide".

Dés lors, tu as deux solutions :
Soit la classe que tu crée a sémantique de valeur, et c'est bel et bien le premier code que tu as donné qui doit être utilisé (à ceci près qu'il faut "cacher ce setNom que je ne saurais voir")
Soit la classe que tu crée a, effectivement, sémantique d'entité, et l'idée sera de créer un tableau de... pointeurs intelligents, par exemple sous une forme proche de (!!! compilateur supportant C++14 requis)
Code:

1 2 3 4 std::vector<std::unique_ptr<Object> listeDePointeurs; auto ptr = std::make_unique<MyObject>("le nom de mon objet"); // MyObject hérite de Object listeDePointeur.emplace_back(std::move(ptr));
(d'autres manières sont possibles ;) )
Hé oui, autre langage, autres habitudes à prendre... Et, si tu veux mon avis, il est primordial de prendre les bonnes habitudes le plus vite possible ;)