C: Правильное освобождение памяти многомерного массива

Хорошо, есть большая путаница, объясняющая, в каком именно порядке должны быть необходимые free() вызовы, поэтому я попытаюсь прояснить, чего люди пытаются добиться и почему.

Начнем с основ, чтобы освободить память, которая была выделена с помощью malloc(), вы просто вызываете free() точно с указателем, который вам дал malloc(). Итак, для этого кода:

int **a = malloc(m * sizeof(int *));

вам нужно соответствие:

free(a);

и для этой строки:

a[i]=malloc(n * sizeof(int));

вам нужно соответствие:

free(a[i]);

внутри аналогичного цикла.

Что усложняется, так это порядок, в котором это должно происходить. Если вы вызываете malloc() несколько раз, чтобы получить несколько разных фрагментов памяти, в общем случае не имеет значения, в каком порядке вы вызываете free(), когда вы с ними покончили. Однако порядок здесь важен по очень конкретной причине: вы используете один фрагмент памяти malloced для хранения указателей на другие фрагменты памяти malloced. Поскольку вы не должны не пытаться читать или записывать память после того, как вы вернули ее с помощью free(), это означает, что вам придется освобождать фрагменты с их указателями, хранящимися в a[i] прежде чем вы освободите сам фрагмент a. Отдельные фрагменты с указателями, хранящиеся в a[i], не зависят друг от друга, и поэтому могут быть freed в любом порядке.

Итак, сложив все это вместе, мы получаем следующее:

for (i = 0; i < m; i++) { 
  free(a[i]);
}
free(a);

И последний совет: при вызове malloc() рассмотрите возможность их изменения:

int **a = malloc(m * sizeof(int *));

a[i]=malloc(n * sizeof(int));

to:

int **a = malloc(m * sizeof(*a));

a[i]=malloc(n * sizeof(*(a[i])));

Что это делает? Компилятор знает, что a — это int **, поэтому он может определить, что sizeof(*a) совпадает с sizeof(int *). Однако, если позже вы передумаете и захотите chars, shorts или longs или что-то еще в своем массиве вместо ints, или вы адаптируете этот код для последующего использования в чем-то другом, вам придется изменить только одну оставшуюся ссылку на int в первую процитированную строку выше, и все остальное автоматически встанет на свои места. Это исключает вероятность незамеченных ошибок в будущем.

Удачи!

Отменить именно то, что вы выделили:

  for (i = 0; i < m; i++) { 
      free(a[i]);
  }
  free(a);

Обратите внимание, что вы должны делать это в обратном порядке, в котором вы изначально выделили память. Если вы сначала сделали free(a), то a[i] будет обращаться к памяти после того, как она будет освобождена, что является неопределенным поведением.

Вам нужно снова повторить массив и сделать столько освобождений, сколько mallocs для указанной памяти, а затем освободить массив указателей.

for (i = 0; i < m; i++) { 
      free (a[i]);
}
free (a);

Пишите операторы распределения в обратном порядке, меняя имена функций, и все будет в порядке.

  //Free the arrays
  for (i = m-1; i >= 0; i--) { 
      free(a[i]);
  }

  free(a);

Конечно, вам не нужно освобождать в том же самом обратном порядке. Вам просто нужно отслеживать освобождение одной и той же памяти ровно один раз и не «забывать» указатели на выделенную память (как это было бы, если бы вы сначала освободили a). Но освобождение памяти в обратном порядке — хороший пример решения последней проблемы.

Как указано в комментариях litb, если выделение/освобождение имеет побочные эффекты (например, операторы new/delete в C++), иногда обратный порядок освобождения может быть более важным, чем в этом конкретном примере.

Я бы вызвал malloc() и free() только один раз:

#include <stdlib.h>
#include <stdio.h> 

int main(void){
  int i, m = 5, n = 20;
  int **a = malloc( m*(sizeof(int*) + n*sizeof(int)) );

  //Initialize the arrays
  for( a[0]=(int*)a+m, i=1; i<m; i++ ) a[i]=a[i-1]+n;

  //...do something with arrays

  //How do I free the **a ?
  free(a);

  return 0;
}