autre éclaircissement sur free

Bonjour,

Le code suivant me semble syntaxiquement valide :

Code:

---

1 2 3 4 5 6 7 8 9 10

int buffer_size= 10; char* buffer1; char* buffer2;   buffer1=( char*) malloc( buffer_size* sizeof( char)); buffer2= buffer1; free( buffer2); /* il est entendu qu'a partir de maintenant free( buffer1); est au moins inutile, voire générateur d'erreur ou pire */

---

Mais est-il fonctionnel ? Est-il complet ?

Merci de votre attention.

Salut,

ce code est effectivement syntaxiquement valide, et devrait fonctionner tel quel, mais est très dangereux : après le free(buffer2), tu auras une erreur d'exécution (segmentation fault) si tu fais :

• free(buffer1) ; // car la mémoire de buffer1 a déjà été libérée, mais buffer1 != NULL
• free(buffer2); // idem

et tu auras peut etre une erreur, peut etre pas, en tout cas le comportement est indéterminé, si tu fais :

• buffer[1] = 'x'; // car la mémoire n'est plus allouée, mais peut quand meme être disponible, ou pas
• idem pour buffer2

Une pratique plus sur serait quelque chose de ce genre (totalement inutile pour le moreau de code seul, mais à adapter)

Code:

---

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

int buffer_size= 10; char* buffer2 = NULL; // buffer2 est accessible partout { char* buffer1; // buffer1 n'est acessible que dans ce bloc buffer1=( char*) malloc( buffer_size* sizeof( char)); buffer2= buffer1; } // ici free(buffer1) provoque une erreur de compilation free( buffer2), buffer2 = NULL; // ici free(buffer2) ne provoque pas d'erreur, car free(NULL) est valide

---

Merci beaucoup pour ton attention ainsi que tes commentaires très instructifs... je connaissais pas l'utilisation de {} pour définir un espace de validité. Ou plutôt, je n'avais pas conscience de son sens en ces termes :oops:. Même si, à la réflexion, çà parait presque trivial ;) ... Faut m'excuser, j'ai jamais écrit de compilateur C ...:lol:
J'ai bien conscience du coté dangereux, je fais ça dans un cas 'extreme' : Je suis en train de remplir, à partir d'un fichier texte, un tableau de structure contenant des mallocs ; le tableau, géré via pointeur, étant lui même un malloc.
Or, au cours du chargement de mon tableau, je détecte un 'meilleur doublon' comme nouvel élément du tableau. Je désalloue les mallocs du 'mauvais doublon' et je memcpy le meilleur doublon à l'adresse du 'mauvais', d'où ma question initiale qui concernait les désallocations futures associées au contenu du 'meilleur doublon'.
Je me rend compte à la rédaction de ce commentaire, que je vais être confronté à la situation suivante :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

int buffer_size= 10; char* buffer1; char* buffer2;   buffer1=( char*) malloc( buffer_size* sizeof( char)); buffer2= buffer1; buffer1=( char*) malloc( buffer_size* sizeof( char)); /* là est ma crainte */   /* pour la complétude */ free( buffer2); free( buffer1);

---

Est-ce fonctionnel ? Est-ce complet ? (il me semble que oui ... ;))

Oui c'est fonctionnel et complet, il n'y a vraiment rien de choquant la dedans :D. Tu libères bien les deux zones mémoires que tu as allouées.
Quand tu fais

Code:

---

buffer1=( char*) malloc( buffer_size* sizeof( char));

---

la deuxième fois, tu alloues un espace mémoire nouveau, et tu fais pointer dessus buffer1, ce qui pourrait entrainer que tu ne pourrais plus avoir accès à l'espace mémoire créé en premier, mais ce n'est pas le cas, puisque buffer2 pointe dessus :ccool:.

Si tu as un doute, tu peux (sous linux, sous windows il y'a forcément un équivalent mais je connais pas) utiliser un outils comme valgrind, qui t'indiquera à l'exécution si tu as des fuites de mémoire, si tu fais des accès mémoire incorrects etc. C'est un très bon outils.

Si tu veux, tu peux poster le code pour lequel tu as un doutes, et on regardera ;)

Merci beaucoup.

Encore une incertitude levée grâce à la C(un)Ltd. :ccool: !!!