C Academy · Lektion

Dangling Pointer

Gefahren durch Use-after-free

Dangling Pointer ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Was ist ein Dangling Pointer

Ein Dangling Pointer zeigt auf Speicher, der bereits freigegeben wurde oder anderweitig nicht mehr gültig ist.

Seine Verwendung führt zu undefiniertem Verhalten: Abstürzen, Speicherbeschädigung oder unauffälligen Fehlern.

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

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

Use After Free

Die häufigste Ursache ist das Lesen oder Schreiben über einen Zeiger, nachdem free aufgerufen wurde.

Der Speicherblock wurde möglicherweise inzwischen für etwas anderes wiederverwendet.

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

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 42;
    free(p);
    /* Reading *p here would be use-after-free. */
    p = NULL;
    printf("avoided use-after-free\n");
    return 0;
}

NULL nach free

Wenn Sie einen Zeiger direkt nach der Freigabe auf NULL setzen, wird eine versehentliche Verwendung zu einem klaren Absturz oder zu einem harmlosen free(NULL).

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

int main(void) {
    char *buf = malloc(10);
    buf[0] = 'A';
    free(buf);
    buf = NULL;
    if (buf == NULL) printf("buf is safely null\n");
    return 0;
}

Zurückgeben einer lokalen Adresse

Das Zurückgeben der Adresse einer lokalen (Stack-)Variablen erzeugt einen Dangling Pointer: Die Variable verschwindet, sobald die Funktion zurückkehrt.

Verwenden Sie stattdessen den Heap oder übergeben Sie einen Puffer.

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

int *make_value(int v) {
    int *p = malloc(sizeof(int));
    *p = v;
    return p;
}

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

Mehrere Zeiger auf einen Block

Wenn zwei Zeiger auf denselben Block verweisen, wird der andere zum Dangling Pointer, sobald der Block über einen der beiden freigegeben wird.

Verwalten Sie die Besitzverhältnisse so, dass nur der Besitzer den Speicher freigibt.

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

int main(void) {
    int *a = malloc(sizeof(int));
    *a = 7;
    int *b = a;
    printf("%d\n", *b);
    free(a);
    a = NULL;
    b = NULL;
    printf("both nulled\n");
    return 0;
}

Dangling Pointer nach realloc

Wenn realloc einen Block verschiebt, wird jeder alte Zeiger auf die vorherige Adresse zu einem Dangling Pointer.

Verwenden Sie ausschließlich den von realloc zurückgegebenen Zeiger.

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

int main(void) {
    int *a = malloc(sizeof(int));
    a[0] = 1;
    int *b = realloc(a, 50 * sizeof(int));
    /* a may now be dangling; use only b. */
    b[0] = 2;
    printf("%d\n", b[0]);
    free(b);
    return 0;
}

Freigeben in einer Hilfsfunktion

Wenn eine Hilfsfunktion einen Block freigibt, bleibt der Zeiger des Aufrufers als Dangling Pointer zurück. Setzen Sie ihn entweder nach dem Aufruf auf NULL oder entwerfen Sie die Hilfsfunktion so, dass sie einen Zeiger auf einen Zeiger entgegennimmt.

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

void destroy(int **p) {
    free(*p);
    *p = NULL;
}

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 5;
    destroy(&p);
    printf("p is %s\n", p == NULL ? "null" : "set");
    return 0;
}

Warum das gefährlich ist

Use-after-free ist gefährlich, weil der Speicher inzwischen andere Daten enthalten kann. Schreibzugriffe können unabhängigen Zustand beschädigen, und Angreifer können dies ausnutzen.

Dangling Pointer durch Gültigkeitsbereiche

Ein Zeiger auf eine Variable mit Block-Gültigkeitsbereich wird ungültig, sobald der Block endet. Bewahren Sie Zeiger nicht länger auf, als das Objekt gültig ist, auf das sie zeigen.

#include <stdio.h>

int main(void) {
    int *p;
    {
        int x = 10;
        p = &x;
        printf("in scope: %d\n", *p);
    }
    /* p now dangles; do not dereference it here. */
    printf("block ended\n");
    return 0;
}

Dangling Pointer erkennen

Tools wie AddressSanitizer und Valgrind erkennen Use-after-free zur Laufzeit und verweisen auf die genaue Zeile.

Erstellen Sie während der Entwicklung Builds mit aktivierten Sanitizern.

Sicherer Lebenszyklus im Code

Reservieren, verwenden, freigeben und auf NULL setzen. Wenn Sie dies konsequent befolgen, verhindern Sie Dangling Pointer.

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

int main(void) {
    int *p = malloc(sizeof(int));
    if (!p) return 1;
    *p = 123;
    printf("%d\n", *p);
    free(p);
    p = NULL;
    return 0;
}

Kurzer Test

Testen Sie Ihr Verständnis von Dangling Pointern.

Zusammenfassung

Sie haben Dangling Pointer kennengelernt:

Sie zeigen auf freigegebenen oder außerhalb des Gültigkeitsbereichs liegenden Speicher; ihre Verwendung führt zu undefiniertem Verhalten.
Vermeiden Sie das Zurückgeben lokaler Adressen. Verwenden Sie einen Zeiger niemals nach free oder nachdem realloc einen Block verschoben hat.
Setzen Sie Zeiger nach der Freigabe auf NULL und verwalten Sie die Besitzverhältnisse.
Verwenden Sie Sanitizer und Valgrind, um Use-after-free zu erkennen.

Häufig gestellte Fragen

Ist die Lektion „Dangling Pointer“ kostenlos?

Ja — der vollständige Text von „Dangling Pointer“ 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 „Dangling Pointer“?

Gefahren durch Use-after-free 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 4 von 4.

Wie lange dauert die Lektion „Dangling Pointer“?

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