Que mettre dans un std::vector : objet, pointeur, référence

Bonjour,

J'avais un std::vector<A>, mais maintenant, mes A peuvent aussi être des A1 (classe dérivée).
Suis-je donc obligée de transformer mon std::vector<A> en std::vector<A*>
(et donc de gérer les pointeur :( ) ou existe-t'il un autre moyen en utilisant des références ?

Merci d'avance.

On ne peut pas stocker des références dans un conteneur, celles-ci n'étant pas des "objets" mais simplement des alias pour d'autres variables.

La meilleure solution pour ne pas s'occuper de la gestion de la mémoire est de stocker des pointeurs intelligents avec comptage de référence ; boost::shared_ptr ou Loki::SmartPtr par exemple.

Merci bien pour ta réponse !
Anne.

Citation:

---

Envoyé par Loulou24

On ne peut pas stocker des références dans un conteneur, celles-ci n'étant pas des "objets" mais simplement des alias pour d'autres variables.

La meilleure solution pour ne pas s'occuper de la gestion de la mémoire est de stocker des pointeurs intelligents avec comptage de référence ; boost::shared_ptr ou Loki::SmartPtr par exemple.

---

Le problème est qu'alors les objets ont une sémentique de pointeur. Dans certains cas, on peut vouloir garder une sémentique par valeur. Dans ce cas, un petit pointeur intelligent fait main avec deep copy peut faire l'affaire. genre :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

template <class T> class ValuePtr { T* myPtr; ValuePtr(T* t) : myPtr(t) {} ~ValuePtr() {delete myPtr;} ValuePtr(ValuePtr const &vptr) : myPtr(vptr->clone();); void swap(ValuePtr &vptr) {std::swap(myPtr, vptr.myPtr);} ValuePtr operator=(ValuePtr const &vptr) {ValuePtr temp(vptr); temp.swap(this); } T* operator->(){return myPtr;} T const * operator->() const {return myPtr;} };

---

Où clone implémente l'idiome du constructeur virtuel.

Je vois le principe, mais je ne comprend pas tout...
C'est quoi swap ?
Et puis : il manque le destructeur pour détruire le pointeur, non ?

Citation:

---

Envoyé par _Anne_

Je vois le principe, mais je ne comprend pas tout...
C'est quoi swap ?

---

C'est une fonction qui échange ses deux valeurs. Elle a la propriété qu'elle ne peut pas lancer d'exception, et donc elle est très utile pour écrire du code exception-safe : Au lieu de modifier directement un objet (par exemple, dans operator=), ce qui peut être gênant si la n-ième modification échoue (comment revenir à l'état initial), on modifie un objet temporaire, puis on échange les deux objets par une fonction dont on sait qu'elle ne pourra pas échouer.

Citation:

---

Envoyé par _Anne_

Et puis : il manque le destructeur pour détruire le pointeur, non ?

---

Oui, effectivement, un ch'tit oubli... Je vais éditer le message précédent pour l'ajouter.

Citation:

---

Envoyé par JolyLoic

Citation:

---

Envoyé par _Anne_

C'est quoi swap ?

---

C'est une fonction qui échange ses deux valeurs. Elle a la propriété qu'elle ne peut pas lancer d'exception, et donc elle est très utile pour écrire du code exception-safe : Au lieu de modifier directement un objet (par exemple, dans operator=), ce qui peut être gênant si la n-ième modification échoue (comment revenir à l'état initial), on modifie un objet temporaire, puis on échange les deux objets par une fonction dont on sait qu'elle ne pourra pas échouer.

---

Pardon, je dois être un peu bête 8O, mais c'est quoi la différence entre :

Code:

---

1 2	FLDptrObj temp(vptr); temp.swap(this);

---

et

Code:

---

myPtr = vptr->clone();

---

:?:

Comme je viens du C, je ne maitrise pas complètement les exceptions... ça doit être ça le problème !

Par ailleurs, est-ce que dans l'affectation (operator=) , il ne va pas y avoir un soucis de fuite de l'ancien pointeur de l'objet courant ?

Quoiqu'il en soit, merci beaucoup pour ton aide :ccool:

Citation:

---

Envoyé par _Anne_

Pardon, je dois être un peu bête 8O, mais c'est quoi la différence entre :

Code:

---

1 2	FLDptrObj temp(vptr); temp.swap(this);

---

et

Code:

---

myPtr = vptr->clone();

---

---

Déjà, le but de clone :

Si tu as B, D1 et D2 qui dérivent de B, alors quand tu possède un pointeur sur B, tu ne peux pas vraiment utiliser le constructeur de copie :

Code:

---

1 2	B* b1 = new D1; B* b2 = new XX (b1); // Suivant le type dynamique de b1, XX devrait être égal à B, D1 ou D2

---

Donc, pour ça, on défini dans B une fonction virtuelle clone, que l'on surcharge dans toutes les classes dérivées. Le code est toujours le même :

Code:

---

B* XX::clone() {return new XX(this);}

---

Donc clone permet d'avoir un constructeur de copie virtuel.

Maintenant, le truc avec swap :
Le but est double : Déjà, implémenter l'operator= à l'aide du constructeur de copie pour factoriser le code, deuxièment avoir un operator= qui en cas de problème n'a pas modifié l'objet auquel on essaye d'affecter.

swap permet d'échanger deux valeurs, sans lancer d'exceptions. On crée donc dans un premier temps un objet temporaire en copiant l'objet passé en paramètre (ce qui appèlera lone). Ensuite, on échange l'objet nouvellement crée avec l'objet courant, puis on laisse cet objet temporaire mourir.

En l'occurence, comme la classe n'a qu'une seule donnée, on aurait pu écrire directement clone, mais la technique avec swap marche dans tous les cas, ce qui n'est pas le cas de l'affectation directe. En particulier, s'il y a plusieurs variables membres et que après la première affectation, une exception est lancée, on se retrouve avec un état incohérent. J'ai donc pris l'habitude d'écrire mes operator= avec swap.

Et de toute façon, founir une fonction swap pour ce genre de classes est une bonne idée, car elle peut être utile à une personne qui écrira un classe contenant un ValuePtr et autre chose, et qui aura donc besoin de swap lui même.

J'espère avoir été plus clair, mais il n'est pas aisé de résumer dans un forum quelque-chose qui aurait plus sa place dans des articles dédiée. Par exemple Sutter en parle dans ses GOTW (http://www.gotw.ca/gotw/008.htm ou http://www.gotw.ca/gotw/059.htm par exemple, )

Citation:

---

Envoyé par _Anne_

Par ailleurs, est-ce que dans l'affectation (operator=) , il ne va pas y avoir un soucis de fuite de l'ancien pointeur de l'objet courant ?

---

Quand l'objet temp sera détruit, ce pointeur sera pris en compte dans le destructeur.

Citation:

---

Envoyé par JolyLoic

Déjà, le but de clone :

---

oui,ça, ça va, j'utilise souvent...

Citation:

---

Envoyé par JolyLoic

Maintenant, le truc avec swap :

---

Ok. Je comprend. Ici, on aurait pu faire plus simple, mais c'est plus général avec swap...

Citation:

---

Envoyé par JolyLoic

J'espère avoir été plus clair,

---

C'est parfait :) merci beaucoup pour cette longue explication :ccool:

Citation:

---

Envoyé par JolyLoic

Citation:

---

Envoyé par _Anne_

Par ailleurs, est-ce que dans l'affectation (operator=) , il ne va pas y avoir un soucis de fuite de l'ancien pointeur de l'objet courant ?

---

Quand l'objet temp sera détruit, ce pointeur sera pris en compte dans le destructeur.

---

ok :bravo: j'avais pas saisi que le swap échange les deux ! super !

Merci encore !!!