Liberare la memoria ed evitare perdite
Esegua correttamente la pulizia.
Liberare la memoria ed evitare perdite è 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.
Ogni malloc richiede un free
La memoria dell'heap rimane riservata finché non la si rilascia con free. Se si perde l'unico puntatore a un blocco senza liberarlo, quella memoria va persa.
Le perdite si accumulano nel tempo e possono esaurire la memoria nei programmi in esecuzione prolungata.
int *a = malloc(100 * sizeof(*a));
/* ... use a ... */
free(a);Che cosa fa realmente free
free(p) restituisce il blocco all'allocatore, che potrà riutilizzarlo. Non modifica il valore di p.
Dopo free, p punta ancora al vecchio indirizzo, che ora non è più valido. Accedervi produce un comportamento indefinito.
free(p);
/* p is now a dangling pointer */La trappola del puntatore pendente
Utilizzare un puntatore dopo averlo liberato è un errore use-after-free. Il programma potrebbe sembrare funzionare, per poi corrompere i dati o terminare in modo imprevedibile.
Una semplice precauzione consiste nell'impostare il puntatore su NULL subito dopo aver liberato la memoria.
free(a);
a = NULL; /* now misuse is a clean NULL deref, easier to catch */Il double free è indefinito
Chiamare free due volte sullo stesso blocco corrompe lo stato interno dell'allocatore e spesso causa un crash.
Impostare il puntatore su NULL dopo il primo free aiuta, perché free(NULL) è esplicitamente sicuro e non esegue alcuna operazione.
free(a);
a = NULL;
free(a); /* free(NULL) is a harmless no-op */Libere solo ciò che ha allocato con malloc
Passi a free solo un puntatore ottenuto da malloc, calloc o realloc.
Liberare l'indirizzo di una variabile dello stack, una stringa letterale o un puntatore che si trova nel mezzo di un blocco produce un comportamento indefinito.
int x = 5;
/* free(&x); WRONG: x is on the stack */
int *p = malloc(sizeof(int));
free(p); /* correct */Perdita causata da un ritorno anticipato
Una perdita comune si verifica quando si alloca memoria e poi si raggiunge un percorso di errore che restituisce il controllo prima di liberarla. Il blocco viene perso.
Si assicuri che ogni percorso di uscita che possiede la memoria la liberi prima di restituire il controllo.
int *a = malloc(n * sizeof(*a));
if (something_failed) {
free(a); /* don't forget this before returning */
return -1;
}Un programma pulito di allocazione e deallocazione
Questo programma alloca, utilizza e libera la memoria lungo ogni percorso, senza causare perdite.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int n = 4;
int *a = malloc(n * sizeof(*a));
if (!a) return 1;
for (int i = 0; i < n; i++) a[i] = i + 1;
int sum = 0;
for (int i = 0; i < n; i++) sum += a[i];
printf("%d\n", sum);
free(a);
a = NULL;
return 0;
}Deallocazione di allocazioni annidate
Se un blocco contiene puntatori ad altri blocchi, liberi prima quelli interni e poi quello esterno.
Liberare prima il blocco esterno farebbe perdere gli indirizzi dei blocchi interni, causando una perdita di memoria.
for (size_t i = 0; i < rows; i++)
free(grid[i]); /* free each row first */
free(grid); /* then the array of pointers */Un proprietario per ogni blocco
Stabilisca quale parte del codice possiede ogni allocazione ed è responsabile della sua deallocazione.
Se due puntatori fanno riferimento allo stesso blocco e lo liberano entrambi, si verifica un double free. Una proprietà chiaramente definita evita questo problema.
Rilevamento delle perdite con gli strumenti
Non è necessario individuare le perdite a vista. Strumenti come valgrind o AddressSanitizer segnalano le perdite e le deallocazioni non valide, indicando i numeri di riga.
Compili con -g ed esegua il programma con lo strumento per vedere esattamente che cosa non è stato liberato.
/* gcc -g -fsanitize=address prog.c && ./a.out */
/* or: valgrind --leak-check=full ./a.out */Libere in ordine inverso rispetto alla configurazione
Una buona abitudine consiste nel rilasciare le risorse nell'ordine inverso rispetto a quello in cui sono state acquisite, quando una funzione ne acquisisce diverse.
In questo modo si rispecchia la struttura delle dipendenze e la pulizia rimane prevedibile.
char *buf = malloc(64);
int *idx = malloc(64 * sizeof(int));
/* ... use them ... */
free(idx); /* free last-acquired first */
free(buf);Controllo rapido
Verifichi la propria comprensione della deallocazione della memoria.
Riepilogo
Abbini ogni allocazione a un solo free, lungo ogni percorso del codice.
Eviti i puntatori pendenti e i double free impostando i puntatori su NULL dopo aver liberato la memoria. Libera prima le allocazioni interne di quelle annidate, assegni un solo proprietario a ogni blocco e utilizzi valgrind o ASan per individuare le perdite. Ora dispone di tutti gli strumenti necessari per lavorare con gli array dinamici.
Impara C con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 39
- Lezioni
- 144
Domande Frequenti
La lezione «Liberare la memoria ed evitare perdite» è gratuita?
Sì — il testo completo di «Liberare la memoria ed evitare perdite» è 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 «Liberare la memoria ed evitare perdite»?
Esegua correttamente la pulizia. 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 «Liberare la memoria ed evitare perdite»?
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
- Allocare un array
- Crescere con realloc
- Un tipo Vector riutilizzabile
- Liberare la memoria ed evitare perdite