C Academy · Lektion

malloc und free

Auf dem Heap reservieren

malloc und free ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Der Heap

Bisher lebten Variablen mit einer festen Lebensdauer auf dem Stack. Mit dem Heap können Sie zur Laufzeit Speicher anfordern und ihn so lange behalten, wie Sie ihn benötigen.

Sie verwalten den Heap-Speicher selbst mithilfe der Funktionen aus <stdlib.h>.

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

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 99;
    printf("%d\n", *p);
    free(p);
    return 0;
}

malloc aufrufen

malloc(size) reserviert size Bytes und gibt einen Zeiger darauf zurück oder bei einem Fehler NULL.

Der Speicher ist nicht initialisiert: Sein Inhalt ist unbestimmt.

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

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 7;
    printf("value = %d\n", *p);
    free(p);
    return 0;
}

Größe mit sizeof bestimmen

Bestimmen Sie die Größe von Speicherreservierungen immer mit sizeof, damit der Code auf jeder Plattform korrekt ist.

Mit sizeof(*p) wird die Größe automatisch an den Typ des Zeigers gebunden.

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

int main(void) {
    double *p = malloc(sizeof(*p));
    *p = 3.14;
    printf("%f\n", *p);
    free(p);
    return 0;
}

NULL immer prüfen

Wenn die Speicherreservierung fehlschlägt, gibt malloc NULL zurück. Eine Dereferenzierung führt zum Absturz des Programms.

Prüfen Sie das Ergebnis, bevor Sie es verwenden.

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

int main(void) {
    int *p = malloc(sizeof(int));
    if (p == NULL) {
        printf("allocation failed\n");
        return 1;
    }
    *p = 5;
    printf("ok: %d\n", *p);
    free(p);
    return 0;
}

Ein Array reservieren

Um viele Elemente aufzunehmen, multiplizieren Sie die Elementgröße mit der Anzahl.

malloc(n * sizeof(int)) schafft Platz für n Ganzzahlen.

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

int main(void) {
    int n = 5;
    int *arr = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) arr[i] = i * i;
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");
    free(arr);
    return 0;
}

Heap-Arrays über Zeiger indizieren

Auf ein Heap-Array wird über seinen Zeiger mit der vertrauten Syntax arr[i] zugegriffen. Sie entspricht *(arr + i).

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

int main(void) {
    int *arr = malloc(3 * sizeof(int));
    arr[0] = 10;
    *(arr + 1) = 20;
    arr[2] = 30;
    printf("%d %d %d\n", arr[0], arr[1], arr[2]);
    free(arr);
    return 0;
}

Speicher freigeben

free(p) gibt den Block an den Allokator zurück. Danach dürfen Sie p nicht mehr verwenden, um auf diesen Speicher zuzugreifen.

Jeder erfolgreiche Aufruf von malloc benötigt einen passenden Aufruf von free.

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

int main(void) {
    char *buf = malloc(16);
    if (buf) {
        buf[0] = 'A';
        printf("%c\n", buf[0]);
        free(buf);
    }
    return 0;
}

free(NULL) ist sicher

Der Aufruf von free mit einem NULL-Zeiger bewirkt nichts und ist vollkommen zulässig.

Dadurch wird Bereinigungscode vereinfacht, der möglicherweise ausgeführt wird, bevor die Speicherreservierung erfolgreich war.

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

int main(void) {
    int *p = NULL;
    free(p);
    printf("free(NULL) was safe\n");
    return 0;
}

Heap-Speicher zurückgeben

Anders als Stack-Variablen bleibt Heap-Speicher nach der Rückkehr aus einer Funktion erhalten. So kann eine Funktion einen Puffer reservieren und zurückgeben.

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

int *make_range(int n) {
    int *a = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) a[i] = i;
    return a;
}

int main(void) {
    int *r = make_range(4);
    printf("%d %d\n", r[0], r[3]);
    free(r);
    return 0;
}

malloc in C nicht casten

In C gibt malloc einen void * zurück, der automatisch in jeden Zeigertyp konvertiert wird.

Ein Cast ist unnötig und kann ein fehlendes Include von <stdlib.h> verschleiern.

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

int main(void) {
    long *p = malloc(sizeof(long));
    *p = 1234567L;
    printf("%ld\n", *p);
    free(p);
    return 0;
}

Nicht doppelt freigeben

Das zweimalige Aufrufen von free für denselben Zeiger führt zu undefiniertem Verhalten und kann den Heap beschädigen.

Setzen Sie den Zeiger nach der Freigabe auf NULL, damit eine versehentliche Wiederverwendung unschädlich bleibt.

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

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 1;
    free(p);
    p = NULL;
    free(p);
    printf("no double free\n");
    return 0;
}

Kurzer Test

Testen Sie Ihr Wissen über malloc und free.

Zusammenfassung

Sie haben die Grundlagen der Heap-Speicherreservierung kennengelernt:

malloc(size) reserviert nicht initialisierte Bytes und gibt bei einem Fehler NULL zurück.
Prüfen Sie immer das Ergebnis und bestimmen Sie die Größe mit sizeof.
free(p) gibt Speicher frei; jeder Aufruf von malloc benötigt genau einen Aufruf von free.
free(NULL) ist sicher; eine doppelte Freigabe ist undefiniert.

Häufig gestellte Fragen

Ist die Lektion „malloc und free“ kostenlos?

Ja — der vollständige Text von „malloc und free“ 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 „malloc und free“?

Auf dem Heap reservieren 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 1 von 4.

Wie lange dauert die Lektion „malloc und free“?

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