libera lo spazio allocato in c con malloc

Question

Ho una domanda su questo codice:

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; 

Quando lo spazio libero allocato per questa struct, prima ho liberare puntatore alla matrice all'interno struct?

Per esempio,

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); 

Grazie in anticipo

Answer 1

Ciò è corretto.

Per contribuire a evitare di sparare in un piede, si potrebbe prendere in considerazione le seguenti pratiche:

1. sempre tutto malloc/memoria calloc'ed di connessione()
2. Successivamente, impostare il puntatore a NULL
gratis
3. Utilizzare una pulizia dedicato/funzione di distruggere per assicurare la coerenza di memoria pulizia

La seguente funzione sarebbe un buon modo per assicurarsi che sempre la pulizia di una struttura adeguatamente, evitare perdite di memoria, ed evitare liberando accidentalmente memoria già liberata e causando un errore di segmentazione:

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); 
} 

esempio:

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; 
} 

Buona fortuna!

Answer 2

Sì.

Ogni chiamata a malloc deve avere una chiamata corrispondente a free.