references, pointeurs, smart pointer ?

hello,

voici un bout de code :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

class toto { public : toto(){}; virtual ~toto(){};   int getIntvalue() {return 10;};   };     class tata { public : tata(){ }; virtual ~tata(){};   toto & getvalue() { toto * t = new toto() ; return *t; };     } ;   int main() { tata t ; int value = t.getvalue().getIntvalue(); return 0; }

---

pour moi il y a une fuite mémoire dans ce code ...
comment faire pour le contourner ?

Faire de t un pointeur intelligent et le retourner.

Existe t il des solutions sans passer par les smart pointer ?

Salut,

Tel que tu le présente, tu dois t'attendre à ce que ton code occasionne une fantastique fuite mémoire.

En effet:

Tu déclare un pointeur auquel tu alloue dynamiquement la mémoire pour un objet.

Jusque là, on pourrait estimer qu'il n'y a pas de problème, sauf que...

Tu renvoie ensuite l'objet pointé (et non le pointeur) sous la forme d'une... référence, or, on ne peut pas prendre l'adresse d'une référence :aie:

Il ne sera donc pas possible de libérer correctement la mémoire allouée à cet objet une fois que tu n'en aura plus besoin.

Au final, chaque fois que tu fera appel à cet fonction, tu te retrouvera avec un espace mémoire alloué dynamiquement équivalent à sizeof(toto) que tu n pourra pas libérer.

Généralement, lorsque tu crées une classe, l'idée est de lui donner les membres qui lui seront nécessaires pour rendre les services que l'on en attend.

Ainsi, si ta classe Tata utilise en interne un objet de type Toto, tu devrais te retrouver avec quelque chose proche de

Code:

---

1 2 3 4 5

class Tata { private: Toto t; };

---

ou, si l'objet de type Toto peut ne pas exister, avec quelque chose proche de

Code:

---

1 2 3 4 5

class Tata { private: Toto* t; };

---

De plus:

Il existe ce que l'on appelle la loi demeter, qui conseille que chaque classe ne donne accès qu'au stricte minimum, (pour être précis, si la classe A utilise en interne un objet de la classe B qui utilise elle-même un objet de la classe C, il n'y a aucune raison pour que l'on puisse accéder à l'objet de type B, et encore moins pour que l'on puisse accéder à l'objet de type C, depuis un objet de type A): Il est donc rarement opportun de présenter un accesseur ( "getter" ).
La règle à suivre, lorsque l'on a vraiment besoin d'exposer un accesseur, est de veiller à éviter les "effets de bord". Il faut donc éviter que, après avoir récupéré la référence sur un membre, il soit possible de modifier ce membre en dehors de la classe d'origine. C'est pourquoi, lorsque l'accesseur renvoie une référence sur un membre, il faut veiller à renvoyer... une référence constante, et à préciser que l'accesseur s'engage à ne pas modifier l'objet en cours.

au final, ta classe Tata devrait ressembler (pour autant qu'il soit opportun d'exposer un accesseur) à quelque chose proche de

Code:

---

1 2 3 4 5 6 7 8

class Tata { public: /* ... */ Toto const & getValue() const{return t;} private: Toto t; };

---

ou, si l'objet de type Toto peut ne pas exister, avec quelque chose proche de

Code:

---

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

class Tata { public: /* ... */ Toto const & getValue() const { if(!t) throw DoesNtExists(); //exception à définir par ailleurs return *t; } private: Toto* t; };

---

Merci pour cette réponse complete
Tu m'apportes certains éclaircissements dont j'avais besoin
Cela dit, je suis embêté quand a la gestion de la durée de vie du pointeur.

Vaut il mieux que le delete soit fait en interne dans le destructeur ? ou à l'extérieur de la classe ?

voici mon code qui je pense est plus optimal :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

class toto { public : toto(){}; virtual ~toto(){};   int getIntvalue() {return 10;};   };     class tata { public : tata(){ t = 0 ; }; virtual ~tata(){ delete t; };   toto & const getvalue() { try{t= new toto(); return *t;}catch(...){delete t; } };   private : toto * t ;   } ;   int main() { tata t ;   int value = t.getvalue().getIntvalue(); return 0; }

---

Imagine que tu appelles n fois getvalue de tata, tu vas faire n new alors que tu feras un seul delete à la destruction de tata. (en prenant comme hypothèse que ton new toto ne renvoi pas d'exception)

Tu ne vas donc pas libérer toute la mémoire que tu as alloué.

hum smart pointer est mon ami