C libre et struct

Ma question est sur C gratuit() la fonction de désallocation des blocs de mémoire précédemment allouée avec malloc().
Si j'ai un struct type de données composé de plusieurs pointeurs, chacun d'eux pointant vers différents emplacements de mémoire, ce qui allait arriver à ces emplacements de mémoire si je demande à free() sur la structure? va que les emplacements d'être libre aussi? ou tout simplement le bloc de mémoire qui allouent le pointeur?

source d'informationauteur Leandro Galluppi

  1. 22

    Pas. Ils ne seront pas libérés. Vous devez les libérer "manuellement". Le malloc ne sait rien sur le contenu de votre structure (il ne sait pas qu'il est une structure à tous, c'est juste un "morceau de la mémoire" de son point de vue).

  2. 9

    Si vous n'gratuit de la structure, de la mémoire pointée par les pointeurs à l'intérieur de la structure ne sera pas libéré (en supposant que c'était mallocd). Vous devez libérer d'abord.

    Vous pouvez utiliser valgrind (si disponible) pour voir par vous-même:

    #include <stdlib.h>
struct resources{
int * aint;
double * adouble;
};                                                                              
int main(){
int* someint = malloc(sizeof(int) * 1024);
double* somedouble = malloc(sizeof(double)* 1024);
struct resources *r  = malloc(sizeof(struct resources));
r->aint = someint;
r->adouble = somedouble;
free (r);
return 0;
}
$ gcc test_struct.c -o test
$ valgrind ./test
==9192== Memcheck, a memory error detector
==9192== Copyright (C) 2002-2009, and GNU GPL'd, by Julian Seward et al.
==9192== Using Valgrind-3.6.0.SVN-Debian and LibVEX; rerun with -h for copyright info
==9192== Command: ./test
==9192== 
==9192== 
==9192== HEAP SUMMARY:
==9192==     in use at exit: 12,288 bytes in 2 blocks
==9192==   total heap usage: 3 allocs, 1 frees, 12,296 bytes allocated
==9192== 
==9192== LEAK SUMMARY:
==9192==    definitely lost: 12,288 bytes in 2 blocks
==9192==    indirectly lost: 0 bytes in 0 blocks
==9192==      possibly lost: 0 bytes in 0 blocks
==9192==    still reachable: 0 bytes in 0 blocks
==9192==         suppressed: 0 bytes in 0 blocks
==9192== Rerun with --leak-check=full to see details of leaked memory
==9192== 
==9192== For counts of detected and suppressed errors, rerun with: -v
==9192== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 12 from 7)
  3. 3
    struct Node
{
struct Node *nextSibling;
struct Node *prevSibling;
struct Node *parentNode;
...
};
...
struct Node *rootNode;
/* Initialize `rootNode' and fill in its various fields;
do the same with more nodes.  */

    Si vous utilisez free(rootNode)il ne sera libéré que le souvenir de ce nœud unique. En d'autres termes, vous aurez un tas de mémoire allouée que vous ne serez pas en mesure de le libérer, à moins que vous gratuit il avant de libérer la mémoire utilisée par le nœud que vous souhaitez supprimer.

  4. 0

    Juste pour préciser sur @Chrono Kitsune de la réponse, il faudrait toujours être possible de libérer les pointeurs à l'intérieur de la structure, mais c'est risqué.

    Ce free(rootNode) n'est en fait dire à la mémoire de l'unité de gestion de l'espace mémoire qui a été utilisée par rootNode n'est pas utilisé plus et le jeu juste pour quoi que ce soit d'autre qui en a besoin. Cependant, rootNode pointe toujours vers le même emplacement, il est maintenant considéré comme un pointeur non valide, et son contenu ne peut en corrompu en raison de sa position peut maintenant être remplacé par d'autres choses.

    Si vous essayez d'accéder à rootNode droite après la libération, travail, mais il n'y a pas de garantie, de sorte qu'il est plus sûr d' free son contenu (qui ont été malloc'd) avant deleteing rootNode lui-même.