C++ Academy · Lezione

Bug comuni della memoria

Evitare memory leak e puntatori pendenti

Bug comuni della memoria è 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.

Perdite di memoria

Si verifica una perdita di memoria quando la memoria nell'heap viene allocata ma non viene mai liberata. Il programma continua a consumare memoria che non può più raggiungere.

void leak() {
    int* p = new int(5);
    // missing delete p;  -> leaked
}

Puntatori pendenti

Un puntatore pendente punta a una memoria che è già stata liberata. Dereferenziarlo produce un comportamento indefinito.

int* p = new int(7);
delete p;
// *p = 3;   // BUG: dangling access

Doppio rilascio

Chiamare due volte delete sullo stesso puntatore corrompe l'heap e spesso causa l'arresto anomalo del programma.

int* p = new int(1);
delete p;
// delete p;   // BUG: double free

Use-after-free

Leggere o scrivere tramite un puntatore dopo l'eliminazione dell'oggetto è un caso di use-after-free, una fonte comune di vulnerabilità di sicurezza.

Sforamento del buffer

Scrivere oltre la fine di un array sovrascrive memoria non correlata. Rimanga sempre entro i limiti.

int a[3] = {1, 2, 3};
// a[3] = 99;   // BUG: out of bounds

delete non corrispondenti

Usare delete su un'allocazione con new[], o viceversa, produce un comportamento indefinito. Li abbini sempre correttamente.

int* arr = new int[4];
// delete arr;   // BUG: should be delete[] arr;
delete[] arr;     // correct

Puntatori non inizializzati

Un puntatore non inizializzato contiene dati casuali. Lo inizializzi sempre con un indirizzo valido o con nullptr.

#include <iostream>

int main() {
    int* p = nullptr;   // safe default
    if (!p) std::cout << "not set\n";
}

Restituire indirizzi locali

Restituire l'indirizzo di una variabile locale nello stack crea immediatamente un puntatore pendente, perché la variabile locale muore al ritorno dalla funzione.

int* bad() {
    int x = 10;
    return &x;   // BUG: x is gone
}

I puntatori smart prevengono le perdite

Sostituire i proprietari grezzi con std::unique_ptr elimina la maggior parte delle perdite e dei doppi rilasci: la pulizia è automatica e avviene una sola volta.

#include <iostream>
#include <memory>

int main() {
    auto p = std::make_unique<int>(5);
    std::cout << *p << "\n";
}   // freed exactly once, automatically

Strumenti per individuare i bug

Strumenti come AddressSanitizer e Valgrind rilevano a runtime perdite, doppi rilasci e accessi oltre i limiti. Li integri nei suoi test.

Prevenire è meglio che rilevare

La soluzione migliore è evitare del tutto la gestione manuale della proprietà: usi contenitori come std::vector e puntatori smart, così sarà la libreria a gestire correttamente la memoria.

Verifica rapida

Verifichi la sua comprensione dei bug di memoria.

Riepilogo

Ha imparato a riconoscere i bug di memoria classici: perdite, puntatori pendenti, doppio rilascio, use-after-free, sforamenti del buffer e delete non corrispondenti. Li prevenga con puntatori smart e contenitori, e individui quelli rimanenti con i sanitizer e Valgrind.

Domande Frequenti

La lezione «Bug comuni della memoria» è gratuita?

Sì — il testo completo di «Bug comuni della memoria» è 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 «Bug comuni della memoria»?

Evitare memory leak e puntatori pendenti 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 «Bug comuni della memoria»?

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

← Torna a C++ Academy