C Academy · Lektion

calloc und realloc

Nullinitialisierten und vergrößerten Speicher verwalten

calloc und realloc ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Über malloc hinaus

Neben malloc bietet die Standardbibliothek calloc für auf null gesetzten Speicher und realloc zum Ändern der Größe eines vorhandenen Blocks.

Beide befinden sich in <stdlib.h>.

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

int main(void) {
    int *p = calloc(3, sizeof(int));
    printf("%d %d %d\n", p[0], p[1], p[2]);
    free(p);
    return 0;
}

calloc setzt Speicher auf null

calloc(count, size) reserviert Platz für count Elemente mit jeweils size Bytes und setzt jedes Byte auf null.

Das ist praktisch, wenn Sie einen sauberen Ausgangszustand benötigen.

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

int main(void) {
    int *a = calloc(5, sizeof(int));
    int sum = 0;
    for (int i = 0; i < 5; i++) sum += a[i];
    printf("sum of zeroed array = %d\n", sum);
    free(a);
    return 0;
}

calloc hat zwei Argumente

Anders als malloc erhält calloc die Anzahl und die Elementgröße als separate Argumente.

Außerdem schützt es vor einem Überlauf bei der Multiplikation von Anzahl und Größe.

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

int main(void) {
    double *d = calloc(4, sizeof(double));
    d[2] = 1.5;
    printf("%f %f\n", d[0], d[2]);
    free(d);
    return 0;
}

malloc im Vergleich zu calloc

Verwenden Sie malloc, wenn Sie ohnehin jedes Byte überschreiben, und calloc, wenn der Speicher anfangs auf null gesetzt sein soll.

calloc benötigt wegen des Nullens etwas mehr Aufwand.

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

int main(void) {
    int *m = malloc(2 * sizeof(int));
    int *c = calloc(2, sizeof(int));
    m[0] = 5; m[1] = 6;
    printf("malloc: %d %d\n", m[0], m[1]);
    printf("calloc: %d %d\n", c[0], c[1]);
    free(m); free(c);
    return 0;
}

Mit realloc vergrößern

realloc(ptr, newsize) ändert die Größe eines Blocks und erhält dessen vorhandenen Inhalt bis zur kleineren der alten und neuen Größen.

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

int main(void) {
    int *a = malloc(2 * sizeof(int));
    a[0] = 1; a[1] = 2;
    a = realloc(a, 4 * sizeof(int));
    a[2] = 3; a[3] = 4;
    for (int i = 0; i < 4; i++) printf("%d ", a[i]);
    printf("\n");
    free(a);
    return 0;
}

realloc kann den Block verschieben

realloc gibt möglicherweise eine andere Adresse zurück, wenn der Block verschoben werden muss, um Platz zu schaffen.

Weisen Sie das Ergebnis immer wieder zu und verwenden Sie den alten Zeiger danach nicht mehr.

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

int main(void) {
    int *a = malloc(sizeof(int));
    a[0] = 42;
    int *bigger = realloc(a, 100 * sizeof(int));
    printf("first element still %d\n", bigger[0]);
    free(bigger);
    return 0;
}

Sicheres realloc-Muster

Wenn realloc fehlschlägt, gibt es NULL zurück, während der ursprüngliche Block erhalten bleibt.

Weisen Sie das Ergebnis zunächst einer temporären Variable zu, damit Sie den alten Zeiger bei einem Fehler nicht verlieren.

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

int main(void) {
    int *a = malloc(2 * sizeof(int));
    int *tmp = realloc(a, 8 * sizeof(int));
    if (tmp == NULL) {
        free(a);
        return 1;
    }
    a = tmp;
    a[7] = 99;
    printf("%d\n", a[7]);
    free(a);
    return 0;
}

Einen Block verkleinern

realloc kann einen Block auch verkleinern. Die führenden Elemente bleiben erhalten, der restliche Speicher wird freigegeben.

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

int main(void) {
    int *a = malloc(6 * sizeof(int));
    for (int i = 0; i < 6; i++) a[i] = i;
    a = realloc(a, 3 * sizeof(int));
    printf("%d %d %d\n", a[0], a[1], a[2]);
    free(a);
    return 0;
}

Ein wachsender Puffer

Ein häufig verwendetes Muster verdoppelt die Kapazität, sobald ein Array voll ist, und verteilt dadurch die Kosten des Wachstums.

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

int main(void) {
    int cap = 2, len = 0;
    int *a = malloc(cap * sizeof(int));
    for (int v = 0; v < 5; v++) {
        if (len == cap) {
            cap *= 2;
            a = realloc(a, cap * sizeof(int));
        }
        a[len++] = v;
    }
    printf("len=%d cap=%d last=%d\n", len, cap, a[len-1]);
    free(a);
    return 0;
}

realloc mit NULL

realloc(NULL, size) verhält sich genau wie malloc(size).

So kann eine Funktion zum Vergrößern die allererste Speicherreservierung einheitlich behandeln.

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

int main(void) {
    int *a = realloc(NULL, 3 * sizeof(int));
    a[0] = 7;
    printf("%d\n", a[0]);
    free(a);
    return 0;
}

Sie kombinieren

Sie können mit calloc einen auf null gesetzten Puffer anlegen und ihn später mit realloc vergrößern. Neue Bytes nach einer Vergrößerung werden nicht auf null gesetzt.

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

int main(void) {
    int *a = calloc(2, sizeof(int));
    a = realloc(a, 4 * sizeof(int));
    a[2] = 0; a[3] = 0;
    printf("%d %d %d %d\n", a[0], a[1], a[2], a[3]);
    free(a);
    return 0;
}

Kurzer Test

Testen Sie Ihr Wissen über calloc und realloc.

Zusammenfassung

Sie haben zwei weitere Werkzeuge zur Speicherreservierung kennengelernt:

calloc(count, size) reserviert auf null gesetzten Speicher und schützt vor einem Multiplikationsüberlauf.
realloc(ptr, newsize) ändert die Größe eines Blocks und verschiebt ihn möglicherweise.
Weisen Sie das Ergebnis von realloc immer einer temporären Variable zu, um bei einem Fehler Speicherverluste zu vermeiden.
realloc(NULL, size) verhält sich wie malloc.

Häufig gestellte Fragen

Ist die Lektion „calloc und realloc“ kostenlos?

Ja — der vollständige Text von „calloc und realloc“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „calloc und realloc“?

Nullinitialisierten und vergrößerten Speicher verwalten Du übst C Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C Academy zu starten?

Keine Vorkenntnisse erforderlich. C Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „calloc und realloc“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C Academy-Lektion Code schreiben und ausführen?

Ja. Jede C Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C Academy