Désallocation d'un CHAR* retourné par une méthode

Hello la communauté,

je me pose une question sur une méthode que je viens de créer.
la voici en très simplifiée

Code:

---

1 2 3 4 5 6 7 8 9 10

CHAR *CClasse::GetAddress(IN const BYTE *adresse, IN const BYTE size) { CHAR *pc_retour; pc_retour = new CHAR[size];   /* traitement ...   ...*/ return pc_retour; }

---

Je crée donc un CHAR*, crée dynamiquement par new, pour retourner mon résultat, mais je ne peux pas désallouer moi-même ce CHAR*, ou alors, quand/comment le faire ?

Merci d'avance pour vos réponses.

Salut,

je ne suis pas sure d'avoir saisie ton problème.

Il faut que tu désaloues ton CHAR* une fois que tu ne t'en sers plus :

Code:

---

1 2 3 4 5

CClasse Classe; CHAR* Array = Classe.GetAddress(..., ...); // Traitement delete[] Array

---

Essaye de préciser ton problème :-)

NeoKript

je vais essayer d'être plus clair dans la méthode, je crée une chaine de caractères dynamiquement : pc_retour = new CHAR[size]
Cette chaine est retournée par ma méthode : return pc_retour

Donc, à chaque appel de ma méthode, la chaine est allouée par new, mais je ne peux la désallouer, car elle est retournée en résultat.

Mon problème est que je ne sais pas quand désallouer cette chaine.
Est-elle désallouer automatiquement après le return ?
Si non, je dois le faire avec un delete, mais je ne vois pas où le placer...

Est-ce que mon problème est plus compréhensible ?
Si non, je réessaie... :D

Citation:

---

Envoyé par niglo

Est-elle désallouer automatiquement après le return ?

---

Non elle n'est pas désallouée automatiquement sinon tu ne pourrais pas te servir de ton CHAR* en dehors de ta méthode.

Citation:

---

Envoyé par niglo

Si non, je dois le faire avec un delete, mais je ne vois pas où le placer...

---

Comme dit dans mon précédent message, il faut que tu désalloue ton CHAR* lorsque tu n'a plus de traitement à faire sur cette variable :

Citation:

---

CClasse Classe;
CHAR* Array = Classe.GetAddress(..., ...);
// Traitement
// Tu fais toutes les opérations que tu souhaites avec ton CHAR*
// Tu le désaloues lorsque tu n'en a plus besoin
delete[] Array;

---

Essaye d'expliquer sur un exemple concret si ce n'est toujours pas ça.

Citation:

---

Envoyé par NeoKript

Salut,

Code:

---

1 2 3 4 5

CClasse Classe; CHAR* Array = Classe.GetAddress(..., ...); // Traitement delete[] Array

---

---

j'avais mal lu ton précédent mail :oops:

Si j'ai bien compris, le CHAR*, utilisé et retourné par ma méthode (pc_retour), va être supprimé lors du delete de Array, qui reçoit le résultat de ma méthode.
C'est bien ça ?

Citation:

---

Envoyé par niglo

j'avais mal lu ton précédent mail :oops:

Si j'ai bien compris, le CHAR*, utilisé et retourné par ma méthode (pc_retour), va être supprimé lors du delete de Array, qui reçoit le résultat de ma méthode.
C'est bien ça ?

---

Tout à fait, c'est lors de l'appel à delete[] que ton pointeur sera desaloué.

Dans une application, il faut que tu ais autant de new que de delete pour pas qu'il y ai de fuite mémoire.

Citation:

---

Envoyé par NeoKript

Dans une application, il faut que tu ais autant de new que de delete pour pas qu'il y ai de fuite mémoire.

---

OK, mais là, je n'aurai pas le même nombre, car le new dans ma méthode, n'aura toujours pas de delete .

Si je l'utilise ainsi :

Code:

---

1 2 3 4 5 6 7

CHAR CharAddressFrom; CharAddressFrom = new CHAR[5]; /*...*/ CharAddressFrom= GetAddress(..., ...); /*...*/ delete[] CharAddressFrom ;

---

le CHAR* crée dans GetAddress n'aura pas son delete. Le delete "delete[] CharAddressFrom" détruit la variable CharAddressFrom et pas la variable pc_retour de ma méthode.
Ou est-ce que le delete va détruire les 2 par "héritage" ?

Citation:

---

Envoyé par niglo

OK, mais là, je n'aurai pas le même nombre, car le new dans ma méthode, n'aura toujours pas de delete .

Si je l'utilise ainsi :

Code:

---

1 2 3 4 5 6 7

CHAR CharAddressFrom; CharAddressFrom = new CHAR[5]; /*...*/ CharAddressFrom= GetAddress(..., ...); /*...*/ delete[] CharAddressFrom ;

---

le CHAR* crée dans GetAddress n'aura pas son delete. Le delete "delete[] CharAddressFrom" détruit la variable CharAddressFrom et pas la variable pc_retour de ma méthode.
Ou est-ce que le delete va détruire les 2 par "héritage" ?

---

Je penses que tu n'as pas tout compris comment fonctionne les pointeurs ^^

Je te fais un petit rappel à ma sauce rapidement, un pointeur en gros c'est l'adresse d'une variable (et non sa valeur !), c'est l'adresse à laquelle on va trouvé la valeur d'une variable dans la mémoire vive.

Du coup, lorsque tu retourne un pointeur dans une méthode c'est une adresse qui est retournée et du coup c'est la même adresse qu'il y a dans
pc_retour et Array.

Le delete[] va donc détruire l'unique pointeur alloué !

J'espère avoir été clair.

NeoKript

merci pour ta réponse.
C'est ce que j'avais compris, mais pas bien exprimé :mouarf:

En tout cas, problème résolu, merci.

Code:

---

1 2 3 4 5 6 7

CHAR CharAddressFrom; CharAddressFrom = new CHAR[5]; /*...*/ CharAddressFrom= GetAddress(..., ...); /*...*/ delete[] CharAddressFrom ;

---

par contre dans ce code, à la ligne 5 tu as une fuite mémoire : tu perds l'unique référence sur ton allocation faite à la ligne 3. Il faut donc soit supprimer la ligne 3 si CharAddressFrom n'est pas utilisé avant la ligne 5 soit ajouter à la ligne 4 un "delete[] CharAddressFrom;"
Et accessoirement, la première ligne devrait être :

Code:

---

CHAR * CharAddressFrom;

---

ou

Code:

---

CHAR [] CharAddressFrom;

---

merci pour ce précieux conseil.

J'ai modifié mon code en fonction de tes remarques pour ne pas avoir cette fuite de mémoire.

Je pense que ta fonction ne devrait pas faire l'allocation, mais que l'appelant devrait allouer sa chaîne de caractères, la passer à ta fonction pour ensuite désallouer la chaîne. ça permettrait de respecter la notion de responsabilité de l'allocation / désallocation.
Ca donnerait ceci :

Code:

---

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

// fonction GetAddress modifiée void CClasse::GetAddress(IN const BYTE *adresse, IN const BYTE size, BYTE * pRetour) { /* traitement ...   ...*/ }   // Appel de GetAddress : CHAR CharAddressFrom; CharAddressFrom = new CHAR[5]; /*...*/ GetAddress(..., 5, CharAddressFrom); /*...*/ delete[] CharAddressFrom ;

---

Enfin, un e petite question, pourquoi n'utilises-tu pas std::string ?

je n'utilise pas String, car j'utilise un framework privé dans lequel les string n'existent pas :(

Euh ... La STL est plutôt publique en fait. Elle est même implémentée partout, donc je ne vois toujours pas pourquoi tu ne l'utilises pas.

Si je devais bosser dans un environnement où les strings ne sont pas disponibles (ça existe, ça ?), la première chose que je ferais est de recréer une classe string à la main. C'est un investissement très vite rentabilisé.

je rouvre le sujet, car j'ai une autre question.

Si j'utilise toujours la même méthode :

Code:

---

1 2 3 4 5 6 7 8 9 10

CHAR *CClasse::GetAddress(IN const BYTE *adresse, IN const BYTE size) { CHAR *pc_retour; pc_retour = new CHAR[size];   /* traitement ...   ...*/ return pc_retour; }

---

comment se passe la désallocation de ma variable "pc_retour" lors de :

Code:

---

printf("Adresse = %s", monObjet->GetAddress());

---

Quelqu'un peut-il éclairer ma lanterne encore obscurcie ?

Citation:

---

Envoyé par niglo

comment se passe la désallocation de ma variable "pc_retour" lors de :

Code:

---

printf("Adresse = %s", monObjet->GetAddress());

---

Quelqu'un peut-il éclairer ma lanterne encore obscurcie ?

---

Tu aura dans ce cas une fuite mémoire (pas de désallocation), afin d'éviter cela il faut faire :

Code:

---

1 2 3 4

CHAR *address = monObjet->GetAddress(); printf("Adresse = %s", address); delete[] address;

---

Pour information, j'ai l'impression que tu mélange un peu c et c++.
printf c'est du C, il serait préférable d'utiliser :

Code:

---

1 2	std::cout << address << std::endl;

---

merci pour ta réponse, c'est bien ce que je pensais, je vais faire les modifs en conséquence.

mais non non, pas de mélange C/C++, j'ai juste repris le message déjà existant qui était du C++.

En général on déconseille ce genre de méthode qui renvoie un pointeur sur un espace mémoire alloué en laissant l'utilisateur de la méthode faire la desallocation. La première raison est que l'utilisateur peut oublier, la seconde est qu'il risque de mal le faire (utiliser un free plutôt qu'un delete, un delete plutôt qu'un delete[] etc.)

Dans ton cas la méthode est dans une classe, ne peux-tu pas stocker ce pointeur dans la classe et le desallouer dans le destructeur de cette classe, si bien sur la durée de vie de la classe est adaptée...

Citation:

---

Envoyé par niglo

merci pour ta réponse, c'est bien ce que je pensais, je vais faire les modifs en conséquence.

mais non non, pas de mélange C/C++, j'ai juste repris le message déjà existant qui était du C++.

---

Pas de quoi, par contre je persiste printf c'est du C et non du C++ ^^