Libération pointeur dans structure

Bonjour,

J'ai besoin de faire des fonctions qui libèrent des structures et les pointeurs qu'elles contiennent.

Code:

---

1 2 3 4 5 6 7 8 9 10 11

typedef struct{ int* p; }structA;   typedef struct{ structA s; }structB;   typedef struct{ structA* s; }structC;

---

Je me demande si je peux faire une seule fonction:

Code:

---

1 2 3 4

void free_structA(structA* s){ free(s->p); free(s); }

---

pour libérer la structA dans 2 cas différents (structB et structC):

Code:

---

1 2 3 4 5

structB b; structC c; [...]allocations[...] free_structA(&b.s); free_structA(c.s);

---

free_structA(&b.s); implique un free sur un pointeur de structA qui n'a pas été crée par un malloc. Cela pose-t-il problème? Ou dois-je faire 2 fonctions de libération pour chacun des cas:
1 - libération des pointeurs contenus dans la structure et de la structure comme ici: free_structA(c.s)
2 - libération des pointeurs contenus dans la structure uniquement: free_pointers_in_structA(&b.s)

Je conseille deux fonctions avec des noms rappelant à quoi ils servent en C++:

Code:

---

1 2 3 4 5 6 7 8 9 10

/* Fonction "destructeur": détruit le contenu d'un objet. */ void destroy_structA(structA* s){ free(s->p); }   /* Fonction "instruction delete": détruit l'objet et libère sa mémoire. */ void delete_structA(structA* s){ destroy_structA(s); free(s); }

---

Et la façon d'appeler ces fonctions:

Code:

---

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

/* Fonction "destructeur" de structB */ void destroy_structB(structB* s){ destroy_structA(&s.s); }   /* Fonction "instruction delete" de structB */ void delete_structB(structA* s){ destroy_structB(s); free(s); }   /* Fonction "destructeur" de structC */ void destroy_structC(structC* s){ delete_structA(s->s); }   /* Fonction "instruction delete": de structC */ void delete_structC(structC* s){ destroy_structC(s); free(s); }

---

Tu remarqueras que le destructeur de structB appelle seulement le destructeur de structA, alors que celui de structC fait un delete.

Quant à la fonction delete, elle fait systématiquement juste un destroy et un free.

Merci, en plus je cherchais un autre nom pour la 2ème fonction c'est parfait. Sinon ça se fait jamais alors un free sans malloc?

C'est ça.

Edit: ok pour ton 2ème message c'est bien ce que je comptais faire dans le cas de 2 fonctions. Encore merci à toi.

Par simple curiosité que ce passe-t-il dans ce cas?

Code:

---

1 2 3

int i; free(i); i = 1;

---

Comportement indéfini? Interdit?

Citation:

---

Envoyé par Nykoo

Comportement indéfini? Interdit?

---

Probablement un comportement indéfini finissant souvent par un crash de l'appli.

Citation:

---

Envoyé par Nykoo

Edit: ok pour ton 2ème message c'est bien ce que je comptais faire dans le cas de 2 fonctions. Encore merci à toi.

Par simple curiausité que ce passe-t-il dans ce cas?

Code:

---

1 2 3

int i; free(i); i = 1;

---

Comportement indéfini? Interdit?

---

free prend en paramètre un pointeur, une adresse.

Oui, finalement si on remet le code comme il aurait pu être plus "juste"

Code:

---

1 2 3 4

int* i = malloc(sizeof(int)); free (i); i = 1;

---

( Veuillez m'excuser, je sais même plus faire un bon malloc, j'ai fais trop de C++ )

Mon, je voulais dire, que ce truc que je viens d'écrire ne plante pas ( pas encore ) juste que l'on aura mis un pointeur qui pointe sur la deuxième case de mémoire du système. Bien sur dès que l'on va vouloir l'utiliser ça plantera, on a pas d'accès à l'adresse mémoire qui nous est pas reservé.

par contre en faisant:

Code:

---

1 2

*i = 1;

---

Ça sera presque équivalent, enfin plus dans le comportement indéfini, car toujours, nous perdons l'accès à la zone mémoire de i car nous avons fait un free. Mais comme le free ne met pas le pointeur à NULL il se peut que le système ne stoppe pas notre programme tout de suite.
Pour cela que je conseillerai de faire toujours des free de ce genre:

Code:

---

1 2 3

free(i); i = NULL;

---

( Pour deux points, déjà car ça plantera plus vite ( donc bug plus facile à repéré ) et puis surtout parce que on peut faire un simple if ( i ) pour savoir si nous pouvons utilisé le i ;) )

Citation:

---

Envoyé par Nykoo

Par simple curiosité que ce passe-t-il dans ce cas?

Code:

---

1 2 3

int i; free(i); i = 1;

---

Comportement indéfini? Interdit?

---

Comportement indéfini. On ne peut libérer que ce qui a été alloué.

Citation:

---

Envoyé par LittleWhite

Oui, finalement si on remet le code comme il aurait pu être plus "juste"

Code:

---

1 2 3 4

int* i = malloc(sizeof(int)); free (i); i = 1;

---

---

Comportement dépendant de l'implémentation. Rien ne prouve que 1 soit une valeur valide pour i.

Je suggère

Code:

---

i = NULL;

---

, voire

Code:

---

free (i), i = NULL;

---

ce qui est le plus cohérent.

Citation:

---

Envoyé par LittleWhite

par contre en faisant:

Code:

---

1 2

*i = 1;

---

Ça sera presque équivalent, enfin plus dans le comportement indéfini,

---

Le comportement est indéfini, car la valeur de i est invalide après le free().