Ausführbare C-Docs: calloc und realloc

Q: Was ist der Unterschied zwischen calloc und malloc in C?

Zwei Unterschiede. calloc(n, size) nimmt Anzahl und Elementgröße getrennt entgegen und prüft, dass ihre Multiplikation nicht überläuft, während malloc(n * size) still umschlagen kann. Und calloc füllt den Block mit Nullen, während malloc ihn so lässt, wie er vorher war.

Q: Wie funktioniert realloc in C?

realloc(p, newsize) liefert einen Block der neuen Größe, in dem dein bisheriger Inhalt bis zur kleineren der beiden Größen erhalten bleibt. Es kann den Block an Ort und Stelle vergrößern oder ihn verschieben, der zurückgegebene Zeiger ist also der einzige, den du weiterverwenden darfst - der alte kann bereits freigegeben sein.

Q: Warum sollte man realloc einem temporären Zeiger zuweisen?

Weil p = realloc(p, n) bei einem Fehlschlag p mit NULL überschreibt, während der ursprüngliche Block weiterhin belegt ist und nichts mehr auf ihn zeigt - ein Leck. Weise zuerst einem tmp zu, prüfe es auf NULL, und schreibe erst dann p = tmp.

malloc beantwortet eine Frage: Gib mir so viele Bytes. Zwei Begleiter in <stdlib.h> beantworten die Fragen, die danach kommen - gib mir so viele Bytes, geleert (calloc) und ich brauche den Block, den ich schon habe, größer (realloc).

calloc: Anzahl, Größe und Nullen

void *calloc(size_t count, size_t size);

Zwei Argumente statt eines, und das Ergebnis ist mit Nullbytes gefüllt.

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

int main(void) {
    size_t n = 6;

    int *counts = calloc(n, sizeof *counts);
    if (counts == NULL) {
        fprintf(stderr, "kein Speicher mehr\n");
        return 1;
    }

    /* bereits null - keine Initialisierungsschleife noetig */
    for (size_t i = 0; i < n; i++) {
        printf("%d ", counts[i]);
    }
    printf("\n");

    counts[2] += 1;
    counts[2] += 1;
    printf("counts[2] = %d\n", counts[2]);

    free(counts);
    return 0;
}

Das ist der klassische Fall: ein Histogramm oder Zählarray, bei dem jeder Platz bei null starten muss. Mit malloc bräuchtest du eine Schleife; calloc erledigt es als Teil der Belegung, oft kostenlos, weil das Betriebssystem frische Seiten ohnehin vorgenullt herausgibt.

Das Überlauf-Argument

Die Aufteilung in zwei Argumente ist nicht kosmetisch. Betrachte eine aus einer Datei gelesene Anzahl:

size_t n = huge_value_from_input;

int *a = malloc(n * sizeof *a);     /* das Produkt kann umschlagen */
int *b = calloc(n, sizeof *b);      /* muss den Überlauf erkennen */

Wenn n * sizeof *a überschreitet, was size_t fassen kann, schlägt es auf eine kleine Zahl um, malloc hat mit einem winzigen Block Erfolg, und jeder nachfolgende Schreibzugriff läuft weit über das Ende hinaus. calloc muss laut Standard stattdessen fehlschlagen und NULL liefern. Wenn eine Größe von außerhalb deines Programms kommt, ist diese Prüfung ihr Geld wert.

Was „genullt" tatsächlich bedeutet

calloc schreibt Null-Bytes. Für Ganzzahlen und Zeichen ist das der Wert null, und das ist, was du willst. Für Zeiger und Gleitkommawerte ist „alle Bits null" auf jeder gängigen Plattform ein Nullzeiger bzw. 0.0, aber der C-Standard verspricht das nicht. Code, der streng portabel sein muss, weist diese ausdrücklich zu.

calloc gegen malloc + memset

int *a = calloc(n, sizeof *a);

int *b = malloc(n * sizeof *b);
if (b != NULL) {
    memset(b, 0, n * sizeof *b);
}

Sie liefern dasselbe Ergebnis. Bevorzuge calloc: Es ist eine Zeile, es macht die Überlaufprüfung, und bei großen Blöcken kann es das Anfassen des Speichers ganz vermeiden. Bevorzuge schlichtes malloc, wenn du ohnehin jedes Byte überschreiben wirst - ein Megabyte zu nullen, das du gleich füllst, ist reine Verschwendung.

realloc: die Größe ändern

void *realloc(void *p, size_t newsize);

realloc liefert einen Block von newsize Bytes, dessen Inhalt bis zur kleineren der beiden Größen dem alten Block entspricht. Es kann den Block dort erweitern, wo er liegt, oder einen neuen belegen, kopieren und den alten freigeben. Du kannst nicht erkennen, was davon, der einzige Zeiger, den du danach benutzen darfst, ist also der zurückgegebene.

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

int main(void) {
    size_t n = 3;
    int *a = malloc(n * sizeof *a);
    if (a == NULL) {
        return 1;
    }
    for (size_t i = 0; i < n; i++) {
        a[i] = (int)i;
    }

    size_t bigger = 6;
    int *tmp = realloc(a, bigger * sizeof *a);
    if (tmp == NULL) {
        free(a);                 /* a ist noch gueltig - gib es frei */
        fprintf(stderr, "Vergroessern fehlgeschlagen\n");
        return 1;
    }
    a = tmp;

    /* die ersten 3 Werte haben ueberlebt; die neuen Plaetze sind uninitialisiert */
    for (size_t i = n; i < bigger; i++) {
        a[i] = (int)(i * 10);
    }

    for (size_t i = 0; i < bigger; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");

    free(a);
    return 0;
}

Das tmp-Zeiger-Idiom

Die drei Zeilen um tmp sind der ganze Grund, warum diese Funktion einen Ruf hat. Die verlockende Kurzform ist kaputt:

/* BUG: verliert den ursprünglichen Block, wenn realloc fehlschlägt */
p = realloc(p, newsize);
if (p == NULL) {
    return;
}

Wenn realloc fehlschlägt, liefert es NULL und lässt den ursprünglichen Block belegt und unverändert. Das Ergebnis direkt in p zu schreiben überschreibt den einzigen Zeiger auf diesen Block, er kann also nie freigegeben werden - ein Leck, und zwar genau dann, wenn Speicher ohnehin knapp ist. Weise tmp zu, prüfe tmp, und übernimm dann:

void *tmp = realloc(p, newsize);
if (tmp == NULL) {
    /* p ist weiterhin gültig; behandle den Fehler, wie es dem Aufrufer passt */
    return 0;
}
p = tmp;

Zwei weitere Verhaltensweisen sind wissenswert: realloc(NULL, n) verhält sich genau wie malloc(n), wodurch eine Wachstumsfunktion ihren ersten Aufruf ohne Sonderfall behandeln kann. Und das Vergrößern lässt die neuen Bytes uninitialisiert - nur der alte Inhalt bleibt erhalten.

Ein Array vergrößern: das Standardmuster

Hier ist das Muster, das fast jeder C-Container verwendet - eine Länge, eine Kapazität und Verdopplung, wenn sie aufeinandertreffen.

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

struct IntVec {
    int   *data;
    size_t len;
    size_t cap;
};

/* liefert 1 bei Erfolg, 0 wenn das Array nicht wachsen konnte */
int vec_push(struct IntVec *v, int value) {
    if (v->len == v->cap) {
        size_t newcap = (v->cap == 0) ? 4 : v->cap * 2;

        int *tmp = realloc(v->data, newcap * sizeof *v->data);
        if (tmp == NULL) {
            return 0;               /* v->data ist unberuehrt und gueltig */
        }
        v->data = tmp;
        v->cap  = newcap;
    }

    v->data[v->len++] = value;
    return 1;
}

int main(void) {
    struct IntVec v = {NULL, 0, 0};

    for (int i = 1; i <= 10; i++) {
        if (!vec_push(&v, i * i)) {
            fprintf(stderr, "kein Speicher mehr bei %d\n", i);
            free(v.data);
            return 1;
        }
    }

    printf("len = %zu, cap = %zu\n", v.len, v.cap);
    for (size_t i = 0; i < v.len; i++) {
        printf("%d ", v.data[i]);
    }
    printf("\n");

    free(v.data);
    v.data = NULL;
    v.len = v.cap = 0;
    return 0;
}

Zwei Entwurfsentscheidungen tragen hier das Gewicht.

Verdoppeln, nicht eins dazuzählen. Um einen festen Betrag zu wachsen lässt jedes Anhängen das ganze Array kopieren, das Füllen von n Elementen kostet also rund n² Bytekopien. Verdoppeln macht die Kopien selten genug, dass jedes Anhängen im Mittel konstante Zeit kostet. Der Start cap == 0 ? 4 : cap * 2 behandelt das erste Anhängen ohne separaten Zweig, weil realloc(NULL, n) einfach malloc ist.

Die Struktur besitzt eine Belegung. v.data wird genau einmal freigegeben, von dem, der die Struktur besitzt. Diese Besitzregel aufzuschreiben - in einem Kommentar oder indem man jedes vec_init mit einem vec_free paart - ist es, was einen wachsenden Container davon abhält zu lecken, während er zwischen Funktionen wandert.

Verkleinern

realloc mit einer kleineren Größe stutzt einen Block, was nützlich ist, nachdem du eine unbekannte Menge Daten in einen überdimensionierten Puffer gelesen hast:

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

int main(void) {
    size_t cap = 1024;
    char *buf = malloc(cap);
    if (buf == NULL) {
        return 1;
    }

    const char *text = "nur ein paar Bytes";
    size_t used = 0;
    while (text[used] != '\0' && used < cap - 1) {
        buf[used] = text[used];
        used++;
    }
    buf[used] = '\0';

    char *tmp = realloc(buf, used + 1);
    if (tmp != NULL) {
        buf = tmp;               /* Verkleinern hat geklappt */
    }
    /* wenn nicht, ist buf weiterhin der groessere Block - vollkommen nutzbar */

    printf("[%s] jetzt %zu gross\n", buf, used + 1);

    free(buf);
    return 0;
}

Ein fehlgeschlagenes Verkleinern ist kein Fehler, für den sich ein Abbruch lohnt: Der alte, größere Block ist weiterhin gültig und weiterhin korrekt. Das ist der eine Fall, in dem es richtig ist, den Fehlschlag zu ignorieren - beachte aber, dass es trotzdem über tmp läuft, denn die Regel, den lebenden Zeiger nicht zu überschreiben, ändert sich nicht.

Wozu man greifen sollte

Was du willst	Nimm
Bytes, Inhalt egal	`malloc(n * sizeof *p)`
Eine Anzahl Elemente, auf null gesetzt	`calloc(n, sizeof *p)`
Eine Anzahl aus nicht vertrauenswürdiger Eingabe	`calloc`, wegen der Überlaufprüfung
Den vorhandenen Block, größer oder kleiner	`realloc` über einen `tmp`-Zeiger
Erste Belegung in einer Wachstumsschleife	`realloc(NULL, n)` - kein Sonderfall

Alle vier werden mit demselben free freigegeben, genau einmal.

Häufige Fehler

p = realloc(p, n) - leckt bei einem Fehlschlag. Geh immer über tmp.
Einen alten Zeiger in den Block behalten. Nach realloc können die Daten verschoben worden sein, jeder gespeicherte Innenzeiger und jede aus einem Index abgeleitete Adresse ist also veraltet. Indizes überleben eine Verschiebung; Zeiger nicht.
Annehmen, die neuen Bytes seien null. Nur calloc nullt. realloc lässt den Zuwachsbereich uninitialisiert.
calloc(n * size, 1) - das wirft die Überlaufprüfung weg, für die es die zweiargumentige Form gibt.
Den alten Zeiger nach einem erfolgreichen realloc freigeben. realloc hat ihn bereits freigegeben; ein zweites free ist ein doppeltes Freigeben.

Häufig gestellte Fragen

Was ist der Unterschied zwischen calloc und malloc in C?

Zwei Unterschiede. calloc(n, size) nimmt Anzahl und Elementgröße getrennt entgegen und prüft, dass ihre Multiplikation nicht überläuft, während malloc(n * size) still umschlagen kann. Und calloc füllt den Block mit Nullen, während malloc ihn so lässt, wie er vorher war.

Wie funktioniert realloc in C?

realloc(p, newsize) liefert einen Block der neuen Größe, in dem dein bisheriger Inhalt bis zur kleineren der beiden Größen erhalten bleibt. Es kann den Block an Ort und Stelle vergrößern oder ihn verschieben, der zurückgegebene Zeiger ist also der einzige, den du weiterverwenden darfst - der alte kann bereits freigegeben sein.

Warum sollte man realloc einem temporären Zeiger zuweisen?

Weil p = realloc(p, n) bei einem Fehlschlag p mit NULL überschreibt, während der ursprüngliche Block weiterhin belegt ist und nichts mehr auf ihn zeigt - ein Leck. Weise zuerst einem tmp zu, prüfe es auf NULL, und schreibe erst dann p = tmp.

Wann sollte ich calloc statt malloc verwenden?

Wenn du den Speicher wirklich genullt brauchst (ein Zählarray, eine Struktur, deren Felder leer starten sollen, ein Puffer, den du nur teilweise füllst) oder wenn die Größe eine Anzahl mal eine Elementgröße ist, die groß werden könnte. Wenn du ohnehin jedes Byte überschreibst, spart malloc die Nullungsarbeit.

Verwandte Konzepte