Discussion :

[niglo]

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 :

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

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.

[NeoKript]

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 C++ :

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

1
2
3
4
5
 
CClasse Classe;
CHAR* Array = Classe.GetAddress(..., ...);
// Traitement
delete[] Array

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

NeoKript

[niglo]

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...

[NeoKript]

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.

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 :

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.

[niglo]

Salut,

Code C++ :

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

1
2
3
4
5
 
CClasse Classe;
CHAR* Array = Classe.GetAddress(..., ...);
// Traitement
delete[] Array

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

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 ?

[NeoKript]

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

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.

[niglo]

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 :

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

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" ?

[NeoKript]

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 :

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

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