Discussion :

[Nykoo]

Bonjour,

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

Code :

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

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 :

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

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 :

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

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)

[Médinoc]

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

Code C :

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

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

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

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.

[Nykoo]

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?

[Médinoc]

C'est ça.

[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 curiosité que ce passe-t-il dans ce cas?

Code :

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

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

Comportement indéfini? Interdit?

[ram-0000]

Comportement indéfini? Interdit?

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

[orfix]

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 :

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

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

Comportement indéfini? Interdit?

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

[LittleWhite]

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

Code :

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

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 :

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

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 :

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

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 )

[Emmanuel Delahaye]

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

Code :

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

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

[Emmanuel Delahaye]

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

Code :

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

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 :

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

i = NULL;

, voire

Code :

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

free (i), i = NULL;

ce qui est le plus cohérent.

[Emmanuel Delahaye]

par contre en faisant:

Code :

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

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