0Pricing
C Academy · Lezione

Dangling pointer

Rischi dell'uso dopo la deallocazione

Dangling pointer è una lezione C Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C Academy include 4 lezioni in totale.

Che cos'è un dangling pointer

Un dangling pointer punta a una zona di memoria già liberata o comunque non più valida.

Utilizzarlo causa un comportamento indefinito: arresti anomali, corruzione dei dati o bug silenziosi.

#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

La causa più comune è leggere o scrivere tramite un puntatore dopo free.

Il blocco potrebbe essere stato riutilizzato per qualcos'altro.

#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 After Free

Impostare un puntatore su NULL subito dopo aver liberato la memoria trasforma un uso accidentale in un arresto anomalo evidente oppure in un innocuo 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;
}

Restituire un indirizzo locale

Restituire l'indirizzo di una variabile locale (sullo stack) crea un dangling pointer: la variabile scompare quando la funzione restituisce il controllo.

Utilizzi l'heap oppure passi invece un buffer.

#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;
}

Più puntatori allo stesso blocco

Se due puntatori fanno riferimento allo stesso blocco, liberarlo tramite uno dei due rende l'altro un dangling pointer.

Tenga traccia della proprietà, in modo che solo il proprietario liberi la memoria.

#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 dopo realloc

Quando realloc sposta un blocco, qualsiasi vecchio puntatore alla posizione precedente diventa un dangling pointer.

Utilizzi solo il puntatore restituito da realloc.

#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;
}

Liberare la memoria in una funzione di supporto

Se una funzione di supporto libera un blocco, il puntatore del chiamante rimane un dangling pointer. Lo imposti su null dopo la chiamata oppure progetti la funzione di supporto in modo che accetti un puntatore a puntatore.

#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;
}

Perché è pericoloso

Use-after-free è pericoloso perché la memoria potrebbe contenere ora altri dati. Le scritture possono corrompere dati indipendenti e gli aggressori possono sfruttare questa vulnerabilità.

Dangling pointer legati all'ambito

Un puntatore a una variabile con ambito limitato a un blocco diventa non valido quando il blocco termina. Mantenga i puntatori non più a lungo della durata dell'oggetto a cui puntano.

#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;
}

Rilevare i dangling pointer

Strumenti come AddressSanitizer e Valgrind rilevano gli use-after-free durante l'esecuzione, indicando la riga esatta.

Durante lo sviluppo, esegua la compilazione con i sanitizer.

Riepilogo del ciclo di vita sicuro nel codice

Allochi, utilizzi, liberi e imposti su null. Seguire sempre questa sequenza impedisce ai puntatori di diventare 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;
}

Verifica rapida

Verifichi la Sua comprensione dei dangling pointer.

Riepilogo

Ha imparato a conoscere i dangling pointer:

  • puntano a memoria liberata o fuori dall'ambito; utilizzarli causa un comportamento indefinito.
  • Evitare di restituire gli indirizzi di variabili locali; non utilizzare mai un puntatore dopo free o dopo che realloc ha spostato un blocco.
  • Impostare i puntatori su NULL dopo aver liberato la memoria e tenere traccia della proprietà.
  • Utilizzare i sanitizer e Valgrind per rilevare gli use-after-free.

Domande Frequenti

La lezione «Dangling pointer» è gratuita?

Sì — il testo completo di «Dangling pointer» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C Academy, passa a CoddyKit PRO. Il corso C Academy include 4 lezioni in totale.

Cosa imparerò in «Dangling pointer»?

Rischi dell'uso dopo la deallocazione Eserciti C Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C Academy?

Non è richiesta alcuna esperienza precedente. C Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Dangling pointer»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C Academy?

Sì. Ogni lezione C Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. malloc e free
  2. calloc e realloc
  3. Memory leak
  4. Dangling pointer
← Torna a C Academy