libérer un double pointeur

J’ai créé une masortingce 2D utilisant un double pointeur comme celui-ci:

int** pt; pt = (int*) malloc(sizeof(int)*10); 

Je sais qu’un pointeur est libéré comme ça

 free(ptr); 

Comment pouvons-nous libérer le double pointeur?

Que se passe-t-il si nous imprimons quelque chose et ensuite libérons cette mémoire et quittons le programme? Est-ce que la mémoire finale est constituée de celle que nous avons utilisée ou sera-t-elle identique à initiale?

Disons que vous avez un mat

 int** mat = malloc(10 * sizeof(int*)); for (int i=0; i<10; ++i) { mat[i] = malloc(10 * sizeof(int)); } 

alors vous pouvez libérer chaque ligne de la masortingce (en supposant que vous les ayez initialisées correctement auparavant):

 for (int i=0; i<10; ++i) { free(mat[i]); } 

puis libérez le pointeur de niveau supérieur:

 free(mat); 

Pour votre deuxième question: si vous allouez de la mémoire et l'utilisez, vous modifierez cette mémoire, qui ne sera pas "restituée" même si vous la libérez (bien que vous ne puissiez plus y accéder de manière fiable / portable).

Remarque : le malloc de niveau supérieur utilise sizeof(int*) lors de l'affectation de pointeur sur entier, et non pas d' int , la taille de int* et int n'est pas garantie d'être identique.

Si votre masortingce n’est pas “en lambeaux”, c’est-à-dire que toutes les lignes ont la même longueur, vous pouvez envisager:

  1. Accéder manuellement, c’est-à-dire le traiter comme un tableau 1D et conserver une valeur de width séparée. Pour accéder à un élément en ( x, y ), utilisez mat[y * width + x] .
  2. Si vous voulez vraiment la commodité de mat[y][x] , vous pouvez l’améliorer en effectuant un seul appel à malloc() qui alloue à la fois le tableau de pointeurs et toutes les lignes, puis en initialisant les pointeurs sur chaque ligne. Cela a l’avantage de pouvoir être libre: édité avec un seul free(mat); appel.

La deuxième approche ressemblerait à ceci:

 double ** masortingx_new(size_t width, size_t height) { double **p = malloc(height * sizeof *p + width * height); double *e1 = (double *) (p + height); size_t i; for(i = 0; i < height; ++i) p[i] = e1 + i * width; return p; } 

Remarque: ce qui précède n’a pas été testé, et le code de production doit évidemment vérifier l’échec avant d’utiliser p .