comment choisir pointeurs et références

Bonjour,

J'aimerais savoir quand est ce qu'on utilise les pointeurs en C++ (dans le cas où on ne mélange pas C et C++) étant donné qu'on utilise les références pour manipuler l'adresse des objets.

Est ce que quelqu'un aurait un cas à montrer où on ne peut pas se passer des pointeurs ?

De manière générale, quand est ce qu'il faut utiliser les pointeurs et quand est ce qu'il faut utiliser les références ?

Merci d'avance pour votre aide

Quand tu peux avoir besoin que ta variable ne référence rien du tout.

Un pointeur peut être nul, alors qu'une référence doit toujours être liée à un objet existant.

Mais le mieux est souvent de passer par un pointeur intelligent.

Salut,

Il y a deux cas principaux :

Le premier, c'est si tu estimes qu'un argument ou une variable peut ne pas exister, et qu'il faut donc pouvoir tester la "non existance" de l'objet.

Une référence étant l'alias d'un objet, elle présente une garantie de non nullité qui est assez embêtante quand il est justement question de faire en sorte que l'objet puisse ne pas exister :aie:

L'exemple classique est celui de n'importe quelle relation parent <--> enfant dans laquelle l'enfant devrait avoir une référence sur son parent mais où l'enfant, qui peut aussi être parent, n'a pas forcément de parent ;)

Le deuxième cas dans lequel l'utilisation de pointeurs est quasiment incontournable, c'est lorsque tu as une fonction renvoyant un objet polymorphe qui devra décider, sur base d'informations récupérées "par ailleurs" du type réel d'un objet polymorphe qu'elle doit créer et que cet objet doit être renvoyé.

Autrement, l'idéal est de partir du principe qu'il vaut mieux utiliser les références chaque fois que possible et les pointeurs si tu n'as vraiment pas d'autre choix ;)

Citation:

---

Envoyé par koala01

Le deuxième cas dans lequel l'utilisation de pointeurs est quasiment incontournable, c'est lorsque tu as une fonction renvoyant un objet polymorphe qui devra décider, sur base d'informations récupérées "par ailleurs" du type réel d'un objet polymorphe qu'elle doit créer et que cet objet doit être renvoyé.

---

Je ne comprends pas cette partie. Tu penses à forcer le type par cast? Si tu as besoin d'une opération spécifique, je ne vois pas pourquoi tu ne passes pas par les méthodes virtuelles.

Non je pense plutôt qu'il parle d'une fonction qui retourne un C*, pouvant être un D* dérivant de C.
Le cas de certaines factory par exemple.
Il est impossible de retourner une référence à ce moment-là.

Code:

---

1 2 3 4 5 6 7 8

class C {}; class D : public C {}; enum TYPE_OF_CLASS { TYPE_C, TYPE_D, }; C* createClass(TYPE_OF_CLASS t) { if (t == TYPE_C) return new C; if (t == TYPE_D) return new D; }

---

Citation:

---

Envoyé par Bousk

Non je pense plutôt qu'il parle d'une fonction qui retourne un C*, pouvant être un D* dérivant de C.
Le cas de certaines factory par exemple.
Il est impossible de retourner une référence à ce moment-là.

Code:

---

1 2 3 4 5 6 7 8

class C {}; class D : public C {}; enum TYPE_OF_CLASS { TYPE_C, TYPE_D, }; C* createClass(TYPE_OF_CLASS t) { if (t == TYPE_C) return new C; if (t == TYPE_D) return new D; }

---

---

Tout à faiit ;)

Il y a un troisième cas où l'utilisation des pointeurs s'avère obligatoire (même s'ils peuvent avantageusement être encapsulés dans des pointeurs intelligents) :

C'est celui où tu veux pouvoir placer des objets polymorphes dans une collection d'objet "passant pour être" du type de base afin d'effectuer un traitement de groupe (basé, a priori, uniquement sur l'interface du type de base, évidemment ;) )

Les références étant des alias des données référencées, on ne peut pas créer de collection de références ;)