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

**karmaki** · 24/08/2004, 13h42

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.

**Laurent Gomila** · 24/08/2004, 13h44

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.

**karmaki** · 24/08/2004, 13h47

Merci bien pour ta réponse !
Anne.

**JolyLoic** · 24/08/2004, 14h14

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

**karmaki** · 24/08/2004, 14h22

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 ?

**JolyLoic** · 24/08/2004, 16h20

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.

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.

**karmaki** · 26/08/2004, 14h33

Envoyé par JolyLoic

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

, mais c'est quoi la différence entre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**JolyLoic** · 26/08/2004, 16h12

Envoyé par _Anne_

Pardon, je dois être un peu bête

, mais c'est quoi la différence entre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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, )

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.