Optimale Weg, Sie zu befreien() malloc ' ed 2D-array in C

Angenommen, ich habe ein 2-dimensionales array, das erstellt wurde, mit etwas wie dieses,

char **foo = (char **) malloc(height * sizeof(char *));
for(i = 0; i <= height; i++) 
    foo[i] = (char *) malloc (width * sizeof(char *));

Zuerst von allen, Ist dies auch der richtige Weg, ein array zu erstellen wie das?. Der Haken an der Sache ist, 'Höhe' und 'Breite' ist etwas, das während der Laufzeit.

Diese scheint zu funktionieren, aber welche ist die beste Strategie, um die Kostenlose 2d-array.
frei(funge) falsch klingt. Gehen durch einige andere Beiträge hier, ich denke ich werde frei haben jeder Zeile eins nach dem anderen?

Ich habe versucht, so etwas wie dieses,

for (height = 0; height < ip_ptr->funge_height; height++) {
    free(funge[height]);
} 
free(funge)

Diese, jedoch gibt mir eine double-free-Zeiger-Ausnahme. Das bedeutet, ich don ' T zu bewältigen haben, dieses Stück der Erinnerung?. Ich war der Eindruck, dass für jedes malloc ' ed Speicher müssen wir den Aufruf free().

Das sollte funktionieren, wenn die Höhe in der erste code ist der gleiche Wert wie ip_ptr->funge_height in der zweiten
Wenn die Breite konstant ist, ist es etwas, das verhindert, dass Sie tun char **foo = (char **) calloc(height * width * sizeof(char)); ?
ja, er kann nicht schreiben Sie dann funge[i][j]; er hat zu schreiben funge[i*width+j];
Es gibt keine Notwendigkeit, umgewandelt den Rückgabewert malloc.
Eigentlich sind es mehrere Dinge falsch. Erste, calloc() nimmt zwei Parameter. Zweitens, es gibt einen Zeiger auf einen Speicherblock, der genau wie malloc(), so dass es nicht das char** Sie erwartet haben. Aber auch, dein char*foo nicht sogar als tordek schlägt vor, mit foo[iwidth+j].

InformationsquelleAutor sudharsh | 2009-10-14

  1. 8

    Da alle die 'Zeilen' sind die gleiche Größe, Sie können nur zuordnen, es in einem ritt, mit malloc(height * width * sizeof (char *)) (es ist nicht ganz klar, ob Sie erstellen ein 2d-array von char oder ein 2d-array von char *). Sie können die Multiplikation zur Berechnung des entsprechenden index (D. H. foo[i][j] wird foo + i * height + j),

    free()ing es ähnlich, nehmen Sie einen einzigen Anruf.

    InformationsquelleAutor Michiel Buddingh

  2. 8

    In der for-Schleife für die Zuordnung, die Sie verwenden i <= height; statt i < height;. Also, Sie schreiben auf einen ungültigen Speicherbereich und das Verhalten des Codes wird unberechenbar.

    Also, wie geht das ansewer eine Frage mit dem Titel "Optimale Weg...". Meintest du das "crash free" von "optimal"?

    InformationsquelleAutor Ponting

  3. 7

    Zweiten Zuteilung werden sollte:

    foo[i] = (char *) malloc (width * sizeof(char));

    du bist auch looping height+1 mal beim zuordnen.

    Außerdem, dass diese beiden snippets scheinen mir Recht sein, so sollte der Fehler woanders sein.

    Wenn das array reserviert wurde, als einen großen Teil des Speichers, dann hätten Sie zu befreien, es einfach einmal.

    char **foo = (char **) malloc(height * sizeof(char *));
*foo = malloc(height * width * sizeof(char))
for (int i = 1; i < height; i++) {
  foo[i] = *foo + i*width;
}
//and you just do 2 frees
free(*foo);
free(foo);
    Dies ist eine viel schnellere Weg, um dies zu tun, werden Aufrufe von malloc sind nicht frei. Immer wieder ruft malloc/free kann auch erhöhen, die Fragmentierung des Speichers, die weiter verlangsamen Zuweisungen.

    InformationsquelleAutor fortran

  4. 3

    Den Mechanismus zu reservieren, ist OK (obwohl Sie sollten die Verwendung sizeof(char) statt sizeof(char *) in der allocate-Schleife; Sie sind overallocating die Zeichenfolgen) angegeben, die Breite und Höhe sind Laufzeit-Werte.

    Den Eindruck, dass Sie anrufen sollen, free() einmal für jedes malloc() ist im Grunde richtig ist (Sachen wie calloc() und realloc() erschweren die einfache Geschichte).

    Loop, gefolgt von freier sollten korrekt sein (oder, mindestens, wird der Allgemeine Mechanismus der " free the sub-arrays zuerst, dann die array von Zeigern auf sub-arrays), so müssen Sie prüfen, wo die double-free-Fehler kommt. Wir können nicht sehen, wo die ip_ptr->funge_height kontrolliert wurde; es ist nicht sofort offensichtlich, dass funge ist beschrieben durch ip_ptr->funge_height.

    Siehe die Antwort von "unknown @ google" - es gibt ein array bounds problem.

    Für was es Wert ist, ich bin mir nicht sicher, alles in der Norm wirklich garantiert, dass sizeof(char *) == sizeof(char **) - möchten Sie vielleicht zu berücksichtigen, daß ein Fehler.
    Es ist eine Garantie, dass Zeiger auf Objekte sind alle von der gleichen Größe. Es ist nicht eine Garantie vom C-standard, die Zeiger auf Funktionen sind, die gleiche Größe wie Zeiger auf Objekte; POSIX bietet, die gewährleisten, statt.
    Irgendwo unten der code, ich nicht ip_ptr->funge_height und ip_ptr->funge_width, um die Werte für Höhe und Breite. Also diese zwei sind die gleichen. Aber ja, die array-Grenzen, problem war ein noob Fehler.

    InformationsquelleAutor Jonathan Leffler

  5. 2

    Wenn Sie den Speicher, es sollte i < height als Schleifenbedingung.

    Beim freigeben von Speicher, Sie sollten die Iteration auf den gleichen index hat wie Sie bei der Zuteilung. ip_ptr->funge_height sollte die gleiche wie das original height, aber es ist offensichtlich nicht so.

    Andere als, dass, sollte es funktionieren.

    Hier ist ein weiterer Weg, der beinhaltet, dass weniger mallocs und frees.

    Reservieren:

    char **foo = malloc (height * sizeof (char **));
foo[0] = malloc (height * width * sizeof (char *));
for (i = 1;  i < height;  ++i) {
    foo[i] = foo[i-1] + width;
}

    Freigeben:

    free (foo[0]);
free (foo);
    Sie sollten nicht multiplizieren Sie die Breite mal sizeof(char*), der compiler schon tut, für Sie, wenn Sie den Mauszeiger korrekt eingegeben haben.
    danke, behoben.

    InformationsquelleAutor dave4420

  6. 0

    Zuweisung (vorausgesetzt, die Höhe > 0 und-Breite > 0)

    char **foo, *row;

assert(height > 0 && width > 0);
foo = malloc(height * sizeof *foo);
row = malloc(height * width * sizeof *row);
assert(foo != NULL && row != NULL);

for (i = 0; i < height; ++i, row += width) 
  foo[i] = row;

assert(row == *foo + height * width);

    Freigabe

    assert(foo != NULL);
free(*foo);
free(foo);

    InformationsquelleAutor AnT

  7. 0

    In solchen Fällen können Sie immer verwenden, valgrind. Nur kompilieren Sie die ausführbare Datei und führen Sie es:

    valgrind --leak-check=full ./a.out

    Valgrind finden alle Ihre Speicher-Validierungen und zeigen Sie auf die code-Zeilen eingebunden.

    In deinem Fall kann es haben, finden Sie die Indizierung problem (< vs. <=) einfach.

    InformationsquelleAutor eyalm

  8. 0

    Wenn dein compiler das unterstützt, könntest du einen Zeiger auf eine variable-Länge-array, dh

    size_t width = 10, height = 5;
char *(*foo)[height][width] = malloc(sizeof *foo);

    Beachten Sie, dass müssen Sie derefence der Zeiger vor dem Zugriff auf die array-Elemente, wie zB

    (*foo)[1][2] = "foo";

    Dies hat den Vorteil, dass Sie erst zuordnen, einem einzigen, kontinuierlichen Speicherblock werden kann freigegeben ist, mit einem einzigen Aufruf fo free().

    InformationsquelleAutor Christoph

  9. 0

    Dieser 100% funktioniert, ohne exe crash.

    char **map2d;
map2d=(char **)malloc(MAXY*sizeof(char *));
for(int a=0; a<MAXY; a++)
    map2d[a]=(char *)malloc(MAXX*sizeof(char));
for(int a=0; a<MAXX; a++)
    free(map2d[a]);
free(map2d);

    InformationsquelleAutor Ruza

Schreibe einen Kommentar