C: Korrektes Freigeben des Speichers eines mehrdimensionalen Arrays

Angenommen, Sie haben den folgenden ANSI-C-Code, der ein mehrdimensionales Array initialisiert:

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

      //Initialize the arrays
      for (i = 0; i < m; i++) { 
          a[i]=malloc(n * sizeof(int));
      }

      //...do something with arrays

      //How do I free the **a ?

      return 0;
}

Nach der Verwendung der **awie befreie ich es korrekt aus dem Speicher?

[Update] (Lösung)

Dank Tims (und der anderen) Antwort kann ich jetzt eine solche Funktion ausführen, um Speicher aus meinem mehrdimensionalen Array freizugeben:

void freeArray(int **a, int m) {
    int i;
    for (i = 0; i < m; ++i) {
        free(a[i]);
    }
    free(a);
}

OK, es gibt ziemlich viel Verwirrung, die genau erklärt, welche Reihenfolge die notwendige ist free() Anrufe müssen eingehen, also werde ich versuchen zu klären, worauf die Leute hinaus wollen und warum.

Beginnen Sie mit den Grundlagen, um Speicherplatz freizugeben, der mit zugewiesen wurde malloc()rufen Sie einfach an free() mit genau dem Zeiger, der Ihnen gegeben wurde malloc(). Also für diesen Code:

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

Du brauchst ein passendes:

free(a);

und für diese Zeile:

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

Du brauchst ein passendes:

free(a[i]);

innerhalb einer ähnlichen Schleife.

Wo dies kompliziert wird, ist die Reihenfolge, in der dies geschehen muss. Wenn Sie anrufen malloc() mehrmals, um verschiedene Speicherblöcke zu erhalten, im Allgemeinen spielt es keine Rolle, in welcher Reihenfolge Sie aufrufen free() wenn du mit ihnen fertig bist. Die Reihenfolge ist hier jedoch aus einem ganz bestimmten Grund wichtig: Sie verwenden einen Teil davon malloced-Speicher, um die Zeiger auf andere Chunks zu halten mallocEd Speicher. Wegen dir muss
nicht Versuchen Sie, den Speicher zu lesen oder zu schreiben, nachdem Sie ihn zurückgegeben haben
free()bedeutet dies, dass Sie die Chunks mit ihren darin gespeicherten Zeigern freigeben müssen a[i] Vor du befreist die a Stück selbst. Die einzelnen Chunks mit darin gespeicherten Zeigern a[i] sind nicht voneinander abhängig und können es auch sein freed in beliebiger Reihenfolge.

Wenn wir das alles zusammenfassen, erhalten wir Folgendes:

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

Ein letzter Tipp: Beim Anrufen malloc()erwägen Sie, diese zu ändern:

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

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

zu:

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

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

Was macht das? Das weiß der Compiler a ist ein int **damit es das feststellen kann sizeof(*a) ist das gleiche wie sizeof(int *). Wenn Sie jedoch später Ihre Meinung ändern und möchten chars oder shorts oder longs oder was auch immer in Ihrem Array statt ints, oder Sie passen diesen Code für die spätere Verwendung in etwas anderem an, müssen Sie nur den einen verbleibenden Verweis auf ändern int in der ersten zitierten Zeile oben, und alles andere ergibt sich automatisch für Sie. Dies beseitigt die Wahrscheinlichkeit von unbemerkten Fehlern in der Zukunft.

Viel Glück!

Machen Sie genau das rückgängig, was Sie zugewiesen haben:

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

Beachten Sie, dass Sie dies im tun müssen umkehren Reihenfolge, aus der Sie den Speicher ursprünglich zugewiesen haben. Wenn du. .. getan hast free(a) Zuerst, dann a[i] würde auf den Speicher zugreifen, nachdem er freigegeben wurde, was ein undefiniertes Verhalten ist.

Sie müssen das Array erneut durchlaufen und so viele Freigaben wie Mallocs für den Speicher, auf den verwiesen wird, ausführen und dann das Array von Zeigern freigeben.

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

Schreiben Sie Ihre Zuweisungsoperatoren in genau umgekehrter Reihenfolge, indem Sie die Funktionsnamen ändern, und alles ist in Ordnung.

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

  free(a);

Natürlich nicht müssen, zu … haben in der gleichen umgekehrten Reihenfolge aufheben. Sie müssen nur den gleichen Speicher genau einmal freigeben und dürfen die Zeiger auf den zugewiesenen Speicher nicht “vergessen” (wie es gewesen wäre, wenn Sie die a Erste). Aber das Aufheben der Zuordnung in umgekehrter Reihenfolge ist eine gute Faustformel, um letzteres anzugehen.

Wie von litb in den Kommentaren angegeben, wenn die Zuweisung/Aufhebung Nebenwirkungen hatte (wie z new/delete Operatoren in C++), wäre manchmal die Rückwärtsreihenfolge der Freigabe wichtiger als in diesem speziellen Beispiel.

Ich würde malloc() und free() nur einmal aufrufen:

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