Libérer la mémoire avec free () ne fonctionne pas

Voici un petit programme qui remplit des tableaux et affiche son contenu à l’écran:

#include  #include  typedef struct{ double **plist; int plistSize; } ParticleList; void sendPar(int *n, int np){ // allocate memory for struct pl ParticleList pl; // allocate memory for ParticleList np times pl.plist = malloc(sizeof(ParticleList) * np); // allocate memory for lists of size n[k] for(int k=0; k<np; k++){ pl.plist[k] = malloc(sizeof(double) * n[k]); } // write some data to the list for(int k=0; k<np; k++){ for(int l=0; l<n[k]; l++){ pl.plist[k][l] = 100000*k+100*l; } pl.plistSize = n[k]; } // print data to check for(int k=0; k<np; k++){ printf("Listsize: %d\n", n[k]); for(int l=0; l<n[k]; l++){ printf("Processor %d, Entry %d, Value %lf\n", k, l, pl.plist[k][l]); } } free(pl.plist); } int main(){ int np = 3; int n[np]; n[0] = 2; n[1] = 4; n[2] = 7; sendPar(n, np); } 

C’est la sortie:

 Listsize: 2 Processor 0, Entry 0, Value 0.000000 Processor 0, Entry 1, Value 100.000000 Listsize: 4 Processor 1, Entry 0, Value 100000.000000 Processor 1, Entry 1, Value 100100.000000 Processor 1, Entry 2, Value 100200.000000 Processor 1, Entry 3, Value 100300.000000 Listsize: 7 Processor 2, Entry 0, Value 200000.000000 Processor 2, Entry 1, Value 200100.000000 Processor 2, Entry 2, Value 200200.000000 Processor 2, Entry 3, Value 200300.000000 Processor 2, Entry 4, Value 200400.000000 Processor 2, Entry 5, Value 200500.000000 

Si je veux maintenant free(pl) la mémoire, utiliser free(pl) ne fonctionne pas. J’ai aussi essayé free(pl.plist) qui fonctionne. Mais que j’ai encore la mémoire de plistSize qui n’est pas désalloué. Quelle est la bonne chose pour libérer la mémoire ici?

Cette allocation de mémoire

 pl.plist = malloc(sizeof(ParticleList) * np); ^^^^^^^^^^^^^^^^^^^ 

n’a pas de sens. je pense que vous voulez dire

 pl.plist = malloc( sizeof( double * ) * np); ^^^^^^^^^^^^^^^^ 

La dernière déclaration de cette boucle

 // write some data to the list for(int k=0; k 

cela n'a pas non plus de sens car l'object scalaire pl.plistSize est écrasé à chaque itération de la boucle externe.

Pour libérer la mémoire allouée, vous pouvez écrire

 for(int k=0; k 

Pl est une variable déclarée statiquement qui contient un pointeur sur un emplacement de mémoire. C’est le tableau de la structure qui doit être libéré.

Le problème pourrait être que vous comprenez mal comment malloc et free fonctionnent.

La variable pl et son membre plistSize ne sont pas atsortingbués par vous. Il est alloué par le compilateur lorsqu’il comstack votre code. Vous ne devriez pas essayer de le libérer.

Libérez seulement ce que vous malloc .

Le problème tel que je le vois, vous pl.plist[k] chaque pl.plist[k] allouée, ce qui entraîne une fuite de mémoire.

Une fois que vous aurez free() -d pl.plist , vous ne pourrez plus libérer les pl.plist[k] s individuelles. La désallocation doit donc se faire dans l’ordre inverse de la répartition.

pl.plist[k] abord chaque pl.plist[k] s, puis pl.plist -le.