Gestione della Memoria Dinamica: `new` e `delete`

LT
Luca Terribili
Autore

La memoria dinamica è gestita principalmente tramite gli operatori new e delete in C++. Questi strumenti consentono al programmatore di richiedere memoria al volo e di restituirla quando non è più necessaria, evitando così che il magazzino si riempia inutilmente. Una gestione corretta è cruciale per mantenere le prestazioni del software, ridurre i memory leak e prevenire crash dovuti a errori di accesso alla memoria.

Nel resto dell’articolo approfondiremo il funzionamento di new e delete, le differenze tra allocazione di singoli oggetti e di array, le implicazioni delle eccezioni durante l’allocazione e le migliori pratiche per scrivere codice C++ sicuro ed efficiente.

Memoria statica e memoria dinamica

La memoria statica viene riservata al momento della compilazione. Variabili globali, statiche e le variabili locali all’interno di una funzione sono tipicamente collocate in questa zona. Il vantaggio principale è la prevedibilità: lo spazio è fissato fin dall’inizio e non cambia durante l’esecuzione, il che rende più semplice il tracciamento delle risorse.

Al contrario, la memoria dinamica (o heap) viene assegnata al volo, quando il programma ne ha effettivamente bisogno. Questo approccio è ideale per strutture dati come liste, alberi o vettori la cui dimensione può variare. Grazie al heap, è possibile creare oggetti di dimensioni sconosciute a compile‑time e liberarli non appena non servono più.

È importante distinguere chiaramente le due tipologie perché un uso improprio della memoria statica può portare a limiti di dimensione, mentre un uso inefficiente della memoria dinamica può provocare memory leak e degrado delle performance. Una buona progettazione prevede l’uso combinato di entrambe le forme, scegliendo la più adatta al contesto specifico.

Come funziona l'operatore new

L'operatore new è il punto di partenza per l'allocazione dinamica in C++. Quando lo invochiamo, specifichiamo il tipo di dato da memorizzare e, se necessario, il numero di elementi per creare un array. Il compilatore richiama il gestore di memoria del sistema operativo, che ricerca nello heap un blocco contiguo di byte sufficienti.

int* numero = new int;          // Alloca spazio per un intero
*numero = 10;                   // Assegna il valore 10

In questo esempio, new int riserva 4 byte (su una piattaforma a 32 bit) e restituisce un puntatore che indica l’indirizzo di memoria appena ottenuto. È fondamentale trattare il puntatore con cura: dimenticarsi di conservarlo o sovrascriverlo può provocare perdite di riferimento, rendendo impossibile il successivo rilascio della memoria.

Quando è necessario allocare più elementi contemporaneamente, si utilizza la sintassi dell’array:

int* numeri = new int[10];      // Alloca spazio per 10 interi
for (int i = 0; i < 10; ++i)
    numeri[i] = i * 2;          // Inizializza ciascun elemento

Il risultato è un blocco continuo di 10 interi nel heap. Il puntatore numeri consente di accedere a ciascun elemento tramite la notazione di indice. È buona norma controllare che l'allocazione sia andata a buon fine, specialmente in ambienti a memoria limitata, perché new può lanciare l’eccezione std::bad_alloc in caso di esaurimento delle risorse.

Come funziona l'operatore delete

L'operatore delete è il contraltare di new e si occupa di rilasciare la memoria precedentemente allocata. Una volta che un oggetto o un array non è più necessario, è buona pratica chiamare delete per restituire il blocco al heap, rendendolo nuovamente disponibile per future richieste.

delete numero;                  // Dealloca un singolo intero

Nel caso di array, è obbligatorio utilizzare la forma con le parentesi quadre:

delete[] numeri;                // Dealloca l’array di 10 interi

Omettere le parentesi quadre (delete numeri) può generare comportamenti indefiniti, perché il compilatore non saprebbe quanti byte rilasciare correttamente. Questo errore è una delle cause più comuni di memory corruption e può portare a crash difficili da diagnosticare.

È importante evitare il doppio delete su uno stesso puntatore. Prima di chiamare delete, è consigliabile impostare il puntatore a nullptr; così, un eventuale tentativo di cancellazione successiva diventa innocuo, poiché delete nullptr è definito come nessuna operazione.

Gestione delle eccezioni durante l'allocazione

L'operatore new può fallire quando il heap non dispone di spazio sufficiente. In tali situazioni, il comportamento predefinito è lanciara l'eccezione std::bad_alloc. Ignorare questa possibilità può far terminare il programma in modo imprevisto.

try {
    int* numero = new int;          // Possibile lancio di std::bad_alloc
    *numero = 42;
    // ... utilizzo di numero ...
    delete numero;
}
catch (const std::bad_alloc& e) {
    std::cerr << "Errore di allocazione: " << e.what() << '\n';
    // Gestione dell'errore: log, fallback, terminazione pulita, ecc.
}

Utilizzare blocchi try‑catch permette di gestire elegantemente la mancanza di memoria, ad esempio liberando risorse alternative o notificando l'utente. Alcune applicazioni critiche, come sistemi embedded, preferiscono l'uso di new (std::nothrow) che restituisce nullptr anziché lanciare un'eccezione, consentendo di verificare direttamente il risultato dell'allocazione.

Indipendentemente dal metodo scelto, è fondamentale documentare sempre le potenziali eccezioni e garantire che ogni percorso di errore includa una corretta deallocazione delle risorse già acquisite, evitando così memory leak e garantendo la stabilità complessiva del programma.

Best practice per una gestione sicura della memoria

  • Inizializzare sempre i puntatori: dichiararli a nullptr subito dopo la definizione riduce il rischio di dereferenziazione di puntatori non validi.
  • Abbinare ogni new a un delete: mantenere una regola di “una chiamata di allocazione, una chiamata di deallocazione” rende più semplice il tracciamento delle risorse.
  • Preferire gli smart pointer (std::unique_ptr, std::shared_ptr) quando possibile: questi gestiscono automaticamente la deallocazione, riducendo la probabilità di errori umani.
  • Evitare il mixing di new/delete e malloc/free: i due meccanismi operano su heap differenti e il loro misto può provocare corruzione della memoria.
  • Utilizzare strumenti di analisi (Valgrind, AddressSanitizer) per rilevare eventuali memory leak o accessi illegali durante lo sviluppo.

Seguendo queste linee guida, è possibile scrivere codice C++ più robusto, più efficiente e meno soggetto a errori di gestione della memoria. Una buona disciplina nella gestione di new e delete contribuisce alla qualità complessiva del software e migliora l’esperienza dell’utente finale.

← Precedente
Successivo →