Fuite de mémoire dans les appels imbriqués ?

Bonjour à tous,

Je suis face à un problème que je ne parviens pas à résoudre.
Soit la ligne suivante, où up et tangage sont des vecteurs (au sens géométrique, pas au sens de structure de stockage) :

Code:

---

1 2	tangage->add(up->times(0.1));

---

La fonction add(Vecteur*) ajoute l'argument à son receveur, et la fonction times(double) renvoie le receveur multiplié par le scalaire passé en argument.

La méthode times(double) crée un nouveau Vecteur, il y a donc un toto=new Vecteur(blabla), et lui donne comme coordonnées les valeurs qui vont bien.
Est-ce que cet appel à new Vecteur(blabla) est à l'origine d'une fuite de mémoire ?

Je me pose la question car je ne vois pas à quel moment le resultat de up->times(0.1) sera détruit.

Si il y a effectuvement une fuite de mémoire, comment faut-il faire ?
Il faut avouer que

Code:

---

1 2 3 4

Vecteur* toto = up->times(0.1); tangage->add(toto); delete toto;

---

est un peu lourd, et encore, il n'y a qu'un niveau d'imbrication.

Ça dépend si add() "prend possession" du vecteur pointé ou non (ou s'il y a possibilité de récupérer le pointeur par la suite).

• Si oui, il n'y a pas de fuite.
• Si non, il y a fuite: Cela peut peut-être être résolu en utilisant des pointeurs intelligents (par exemple, faire retourner un pointeur intelligent par times()).

Merci pour ces précisions. J'ignorais jusqu'à l'existence des pointeurs intelligents.

Salut,

Ceci dit, si les données du vecteur sont copiables, pourquoi ne pas utiliser les conteneurs de la STL, sans allocation dynamique de la mémoire de ta main :question:

Tu modifie ton code pour que up->times() renvoie une référence constante sur le conteneur, et pour que add prenne... une référence constante vers le conteneur en tant qu'argument, "et le tour est joué" :D

Mieux, encore, tu n'expose pas une fonction times qui renvoie l'ensemble du vecteur, mais deux fonction (timeBegin() et timeEnd() :question:) qui renvoie... un itérateur constant, respectivement sur le début et sur l'itérateur qui suit le dernier élément de ton conteneur, et tu modifie la add en conséquence sous une forme proche de

Code:

---

1 2 3 4 5

retour LeTypeDeTangage::add(timeIterator & begin, timeIterator & end) { /* ajout de la plage allant entre begin et end au membre */ }

---

qui sera appelée sous une forme proche de

Code:

---

tangage->add(uptime->timeBegin(1.0),uptime->timeEnd(1.0));

---

(le tout, avec un typedef définissant timeIterator comme... l'itérateur adequat;))

Koala, l'auteur du post original a pourtant bien précisé que c'était des vecteurs au sens mathématique du terme et non au sens conteneur :mouarf:

Je dirais que t'es un peu HS :aie:

Effectivement, du moins, pour la deuxième partie de la réponse...

Cependant, je reste convaincu que le fait de passer par des pointeurs vers des Vecteurs reste une erreur monumentale :p

Citation:

---

Envoyé par Linschn

Merci pour ces précisions. J'ignorais jusqu'à l'existence des pointeurs intelligents.

---

Salut,
Un peu de lecture alors :
Présentation des pointeurs intelligents en C++ par Loïc Joly
Gérer ses ressources de manière robuste en C++ par Aurélien Regat-Barrel
Boost.SmartPtr : Les pointeurs intelligents de Boost par Matthieu Brucher

Merci pour les liens. J'étais tombé sur les deux premiers en cherchant ce que sont les pointeurs intelligents.

Il y a toujours quelque chose que je me demande. Si la méthode times(double) (qui ne modifie pas son receveur) crée un nouvel objet avec new, et le renvoie cette fois-ci par référence, celui ci sera-t-il détruit proprement à la fin du bloc si :

• Il est stocké dans une variable ?
  Code:

  ---

  1 2	Vecteur tmp = toto->times(2.); titi->add(&tmp);

  ---

• Il est passé directement en argument de add(Vecteur&) ?
  Code:

  ---

  1 2	titi->add(toto->times(2.));

  ---

Mon utilisation forcenée des pointeurs vient du fait que je n'ai fait qu'une fois du C++, et je croyais connaitre le langage, mais j'ai surtout fait du C...

Il y a forcément l'un de ces codes qui est mauvais:

• Si add() prend possession du pointeur pour le détruire avec delete lors de la destruction de la liste, le premier code tentera de deleter un objet sur la pile lors de la destruction de la liste --> Aie!
• Si add() ne prend pas possession du pointeur, alors le pointeur retourné par times() sera sans doute "perdu" dans une fuite de mémoire, à moins qu'on ne le détruise explicitement (genre, s'il est possible de faire delete titi[index]).

Il faut plus de contexte pour dire si quelque chose est une fuite ou non, car il n'y a pas réellement de fuite tant qu'il existe un pointeur accessible sur les données...

Il s'agit de vecteurs géométriques, mais peu importe, j'aurais dû prendre autre chose pour mon exemple.

Citation:

---

Si add() ne prend pas possession du pointeur, alors le pointeur retourné par times() sera sans doute "perdu" dans une fuite de mémoire, à moins qu'on ne le détruise explicitement (genre, s'il est possible de faire delete titi[index]).

---

times() renvoie une référence, est-ce qu'il faut quand même détruire l'instance ?

Ce que je pense c'est que quand on le stocke dans une variable, elle est détruite à la fin du bloc, donc tout va bien, et quand on le file directement, il est détruit avec la pile, donc tout va bien aussi, mais je tiens à en être sûr, et la présence d'un new dans la fonction times() me fait penser que je me plante peut-être.

Dans le cas où je me plante, comment peut-on imbriquer deux fonctions sans fuite de mémoire ? Les pointeurs intelligents sont-ils la seule solution (en sont-ils une) ?

Poste le code de times, sinon on ne va pas s'en sortir.

Et vite, ou tu devras attendre une heure et demie pour la réponse (transports).

En fait pour l'instant, times() renvoie un pointeur, comme j'aurais fait en C :

Code:

---

1 2 3 4 5 6

Vecteur* Vecteur::times(double scalaire) { Vecteur* answer=new Vecteur((this->X)*scalaire,(this->Y)*scalaire,(this->Z)*scalaire); return answer; }

---

mais cela oblige à des acrobaties dans le code client :

Code:

---

1 2 3 4 5

Vecteur* tmp = view->times(0.01); derivee->add(tmp); delete tmp; tmp=NULL;

---

En fait, je cherche un moyen de faire ce qui mathématiquement s'écrirait :
V<- V + a*U
Avec ma fonction times, qui renvoie le receveur multiplié, sans modifier le receveur, et add, qui modifie le receveur, ça donne :

Code:

---

1 2	V->add(U->times(a));

---

Sauf que je ne sais pas comment faire pour éviter la fuite de mémoire : times() est obligé de renvoyer un nouvel objet, je ne vois pas d'autre moyen de le détruire que de passer par un pointeur intelligent, ce qui me semble être l'artillerie lourde pour écraser une mouche, mais je me trompe peut-être.

Vecteur ne m'a pas l'air d'être un gros objet.
Pour moi, c'est typpiquement le genre de truc que tu devrais gérer entièrement par valeur, surtout que ça a une sémantique de valeur...

Effectivement, ça en a tout l'air.
F.A.Q. : Quand est-ce qu'une classe a une sémantique de valeur ?
;)

Merci beaucoup !