Risposta.

Storia della questione:

Il C++ è stato progettato sin dall'inizio con un focus sulle prestazioni, quindi la gestione delle risorse (memoria, file, flussi, socket) avviene frequentemente manualmente. In caso di eccezione, è necessario liberare le risorse acquisite. Lo stack unwinding è un meccanismo utilizzato dal C++ per terminare correttamente le funzioni durante il sollevamento di un'eccezione.

Problema:

Quando viene sollevata un'eccezione, il controllo passa immediatamente ai blocchi catch, e le funzioni intermedie vengono "srotolate": i loro distruttori vengono chiamati, ma le chiamate esplicite alle funzioni di rilascio possono essere trascurate (ad esempio, se non vengono utilizzati oggetti che rilasciano automaticamente le risorse).

Soluzione:

In C++, il rilascio delle risorse dovrebbe essere affidato ai distruttori, invece di chiamare manualmente le funzioni di liberazione. Il pattern RAII (Resource Acquisition Is Initialization) è un modo chiaro per rendere automatico il rilascio di una risorsa. Durante lo stack unwinding, verrà chiamato il distruttore e la risorsa verrà liberata indipendentemente dal percorso di uscita dalla funzione.

Esempio di codice:

#include <fstream>
#include <stdexcept>

void readFile(const std::string& filename) {
    std::ifstream file(filename); // Si aprirà e si chiuderà correttamente anche in caso di eccezione
    if (!file.is_open()) {
        throw std::runtime_error("Il file non può essere aperto");
    }
    // ... leggiamo il file
} // file si chiuderà anche in caso di eccezione

Caratteristiche chiave:

Stack unwinding è un meccanismo standard di distruzione degli oggetti durante il sollevamento di un'eccezione.
Rilascia sempre le risorse nei distruttori.
Utilizza RAII o classi standard (ad esempio, smart pointer).

Domande trabocchetto.

Se nel codice c'è delete ptr; nel blocco catch, è sufficiente per la pulizia della memoria?

No, se tra l'allocazione di memoria e il blocco catch si verifica un'eccezione, la memoria potrebbe non essere liberata. È meglio utilizzare std::unique_ptr o scrivere delete nel distruttore.

Esempio di codice:

void foo() {
    int* data = new int[10];
    // ...
    throw std::runtime_error("fail");
    delete[] data; // non verrà chiamato in caso di eccezione
}

Può lo stack unwinding saltare la chiamata al distruttore per un oggetto allocato nello stack?

No, tutti gli oggetti locali (non distrutti fino al punto di sollevamento dell'eccezione) verranno distrutti in ordine inverso di creazione, i distruttori verranno chiamati garantiti.

È possibile utilizzare goto o longjmp per uscire dal blocco try e contare sulla chiamata ai distruttori?

No. Il C++ garantisce la chiamata ai distruttori solo durante lo stack unwinding a causa di un'eccezione, non a causa di una gestione del flusso non corretta (goto, setjmp/longjmp).

Errori comuni e anti-pattern

Pulire le risorse manualmente all'interno di try-catch, ignorando i distruttori
Utilizzare puntatori grezzi invece di RAII o classi standard
Astrarre la gestione delle eccezioni in modo che le risorse non vengano liberate (ad esempio, setjmp/longjmp)

Esempio reale

Caso negativo

Un programmatore alloca memoria utilizzando new, gestisce le eccezioni liberando la memoria nel blocco catch, ma dimentica gli altri modi di uscire dalla funzione.

Vantaggi:

Inizialmente sembra semplice e "trasparente"

Svantaggi:

Se l'eccezione è sollevata non dove ci si aspettava, si verifica una perdita di memoria
Difficile da testare e mantenere

Caso positivo

Si utilizza std::unique_ptr e classi RAII per tutte le risorse, il rilascio non dipende da try/catch.