libre el espacio asignado en C con malloc

Question

Tengo una pregunta acerca de este código:

typedef struct pop { 
unsigned long int *np; // matrix 
unsigned long int f; 
long double fp; 
unsigned long int *R; // matrix 
unsigned long int *C; // matrix 
unsigned long int Dp; 
unsigned long int Ds; 
unsigned long int count; 
struct popolazione *ptrTempLst; // pointer 
struct popolazione *leftTree; // left tree pointer 
struct popolazione *rightTree; // right tree pointer 
} Node; 

Cuando el espacio libre asignado a esta estructura, antes he de liberar puntero a la matriz dentro de estructura?

Por ejemplo,

Node *ptr=(Node *) malloc(sizeOf(Node)); 
ptr->np=(unsigned long int *)malloc(10*sizeOf(unsigned long int)); 

/*code code code*/ 

// is necessary: free(ptr->np); 

free(ptr); 

Gracias de antemano

Answer 1

Eso es correcto.

Para ayudar a evitar pegarse un tiro en el pie, se podría considerar las siguientes prácticas:

1. siempre libre de todo malloc memoria/calloc'ed con conexión()
2. A continuación, ajuste el puntero a NULL
3. Utilice una limpieza dedicada/función de destruir para garantizar la limpieza de memoria coherente

La siguiente función sería una buena manera de asegurarse de que siempre la limpieza de una estructura adecuada, evitar pérdidas de memoria, y evitar que accidentalmente liberar memoria liberada ya-y causando un fallo de segmentación:

int destroyNode(Node* myNode) { 
    if(!myNode) { 
    printf("Invalid pointer! Exiting"); 
    return (-1); 
    } 

    // Clear out memory 
    if(np) { 
    free(np); 
    np = NULL; 
    } 
    if(R) { 
    free(R); 
    R = NULL; 
    } 
    if(C) { 
    free(C); 
    C = NULL; 
    } 
    if(ptrTempLst) { 
    free(ptrTempLst); 
    ptrTempLst = NULL; 
    } 
    if(leftTree) { 
    free(leftTree); 
    leftTree = NULL; 
    } 
    if(rightTree) { 
    free(rightTree); 
    rightTree = NULL; 
    } 

    free(myNode); 
} 

por ejemplo:

int main(void) { 
    Node *tempNode = calloc((size_t)1,sizeof(Node)); 

    // Alloc the member nodes, etc, do some code 


    // Ready to clean up and exit program 
    destroyNode(tempNode); 
    tempNode = NULL; 

    return 0; 
} 

Buena suerte!

Answer 2

Sí.

Cada llamada al malloc debe tener una llamada coincidente al free.