Libération de double pointeurs

Bonjour,

Pour éviter les fuites mémoires j'aimerai libérer les différents pointeurs appelés par ma fonction.
Le problème est que je ne suis pas bien sûre de ce que je dois libérer et comment.

En effet si j'ai

Code:

---

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

{   long **pointeur1; long *ptr2; long *ptr3;   pointeur1= (long**)calloc (taille1,sizeof(long)); prt2 = (long*)calloc (taille2,sizeof(long));   calculs calculs calculs;   free(pointeur1); free(ptr2); free(ptr3); }

---

J'aimerai savoir

1) Si les pointeurs et double pointeurs sont libérés de la même manière ou si je dois libérer 2 fois le double pointeur, dans ce cas là comment ?

2) Faut il aussi faire free(ptr3) s'il n'y a pas eu de calloc fait sur ce pointeur ?

3) Et enfin : dois-je écrire
pointeur1 = NULL; ptr2 = NULL;
après les avoir libérés ?
(et si oui, pourquoi ?)


Merci beaucoup.

Bonjour,

1°/ oui on desalloue de la meme maniere qu'on alloue de l espace pour un objet ou un pointeur.

par contre pour l allocation de pointeur1 je ferais plus comme ca :

Code:

---

1 2 3

pointeur1= calloc (taille1,sizeof(long*)); // les cast sont inutile lors des allocations, et on allue un pointeur pas directement l objet *pointeur1 = calloc (taille1,sizeof(long));

---

c'est pas super logique comme ca (dans le sens ou je vois mal l'utilité) mais c'est comme ca

2°/ non on ne libere que ce qu on alloue

3°/ c'est mieux de mettre a NULL, c'est une bonne habitude a prendre. Ca permet entre autre de faire des test monpointeur == NULL par la suite pour savoir si je peux le réutiliser.

Un pointeur contient une adresse. Si cette adresse est celle d'un bloc mémoire obtenu par malloc,calloc,... (et rangée dans un pointeur pour être conservée), alors, il faut faire un free sur cette adresse une et une seule fois.
exemples :

Code:

---

1 2 3 4 5 6 7 8 9 10

long unlong; long **pointeur1; long *ptr2; long *ptr3; long *ptr4;   pointeur1= calloc (taille1,sizeof(long*)); prt2 = calloc (taille2,sizeof(long)); ptr3 = ptr2; ptr4 = &unlong;

---

- Il faut libérer la mémoire allouée par le premier calloc. L'adresse est dans pointeur1 : faire free(pointeur1)

- Il faut libérer la mémoire allouée par le second calloc. L'adresse est dans ptr2 et dans ptr3 : faire free(ptr2) OU free(ptr3), mais pas les deux !

- ptr4 contient l'adresse de unlong. Cette zone mémoire n'a pas été allouée par *alloc. Il ne faut PAS faire de free(ptr4)

Les free() effectués, les zones mémoires allouées par *alloc ne sont plus disponibles et les adresses correspondantes sont devenues invalides mais rien dans les valeurs de pointeur1, ptr2 et ptr3 ne l'indique. Si on est sûr de ne plus utiliser aucune des trois valeurs, ce n'est pas grave. Sinon, il est prudent de mettre une valeur précisant que l'adresse dans ces pointeurs est l'adresse de "rien" en leur affectant à tous les trois la valeur NULL.

Merci beaucoup

Je vais maintenant pouvoir refaire le tour de mon code pour vérifier que tout a été alloué et libéré correctement :o)

Ah zut non j'ai une autre question en fait :oops:

Je crée une fonction

Code:

---

1 2 3 4 5

long MaFonction(double param1, float **paramResultat) { paramResultat = calloc(tailleRes, sizeof(float*)); }

---

je veux donc réutiliser ce sur quoi pointe paramResultat plus tard, je ne peux donc pas la libérer à la fin de ma fonction.
Est ce que faire

Code:

---

1 2 3 4 5 6 7 8 9 10 11

long FonctionAppel() { long param; float *fRes; MaFonction( param, &fRes);   free(fRes);   fRes = NULL; }

---

permet de libérer le pointeur alloué dans MaFonction correctement ?

merci

Non, mais pour une autre raison :

Code:

---

1 2 3 4

long MaFonction(double param1, float **paramResultat) { paramResultat = calloc(tailleRes, sizeof(float*)); }

---

Ceci modifie le paramètre local à la fonction paramResultat et non pas l'objet dont l'adresse est passée en argument lors de l'appel.

Si cette fonction doit allouer un tableau de float* :

Code:

---

1 2 3 4

long MaFonction(double param1, float ***paramResultat) { *paramResultat = calloc(tailleRes, sizeof(float*)); }

---

Pour l'appel :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

long FonctionAppel() { long param; float **fRes; MaFonction( param, &fRes); free(fRes); fRes = NULL; // Si on veut return .... }

---

Reponse non.

Avant d'aller plus loin pourquoi passer par des pointeur de pointeur (**) ?
Un pointeur de pointeur est generalement utiliser pour passer l'adresse du premier element d'un tableau, or ici ton float semble unique. Dons si tu veux uniquement modifier la valeur de ton parametre (et eviter la recopie en sortie de methode) ce bout de code suffit :

Code:

---

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

long FonctionAppel() { long param; float fRes; MaFonction( param, &fRes);   //free(fRes); inutile du coup   fRes = NULL; }     long MaFonction(double param1, float *paramResultat) { //paramResultat = calloc(tailleRes, sizeof(float*)); *paramResultat = 42; }

---

OK merci :)

En revanche le pointeur de pointeur est malheureusement bien indispensable dans mon cas que j'ai ici simplifié mais c'est tout un shmilblick interne qui fait que je ne peux y echapper :)