Eccezioni in C++

La gestione delle eccezioni è un meccanismo fondamentale in C++ che consente di affrontare errori e situazioni eccezionali in modo sicuro e strutturato. Le eccezioni sono eventi imprevisti che possono verificarsi durante l’esecuzione di un programma e che interrompono il normale flusso di esecuzione. In questo articolo, esploreremo il concetto di gestione delle eccezioni in C++, come dichiarare, lanciare e catturare eccezioni, e come utilizzarle per gestire situazioni eccezionali in modo efficace.

Cos’è un’Eccezione?

Un’eccezione è un oggetto o un valore che rappresenta un errore o una situazione eccezionale che si verifica durante l’esecuzione di un programma. Le eccezioni possono essere causate da vari fattori, come errori di input, divisioni per zero, mancanza di memoria e così via. Invece di gestire questi errori in modo non strutturato, la gestione delle eccezioni consente di affrontarli in modo ordinato.

Dichiarare un’Eccezione

Per dichiarare un’eccezione in C++, è possibile utilizzare la parola chiave throw, seguita da un oggetto o un valore che rappresenta l’eccezione. Ad esempio:

throw 42; // Lancio un'eccezione con il valore 42

Nel codice sopra, stiamo lanciando un’eccezione con il valore 42. Tuttavia, è comune lanciare oggetti di classi specifiche per rappresentare eccezioni più dettagliate.

Catturare un’Eccezione

Per catturare un’eccezione e gestirla, è possibile utilizzare il blocco try-catch. All’interno del blocco try, si inserisce il codice che potrebbe generare un’eccezione, mentre nel blocco catch, si specifica come gestire l’eccezione. Ad esempio:

try {
    // Codice che potrebbe generare un'eccezione
    throw 42; // Lancio un'eccezione con il valore 42
}
catch (int e) {
    // Gestisco l'eccezione di tipo int
    std::cout << "Eccezione catturata: " << e << std::endl;
}

In questo esempio, stiamo cercando di catturare un’eccezione di tipo int generata dal lancio dell’eccezione con il valore 42. Nel blocco catch, gestiamo l’eccezione stampando un messaggio.

Gestione Multipla delle Eccezioni

È possibile catturare e gestire più tipi di eccezioni separatamente utilizzando più blocchi catch. Questo consente di affrontare diversi tipi di errori in modo specifico. Ad esempio:

try {
    // Codice che potrebbe generare un'eccezione
    throw 42; // Lancio un'eccezione con il valore 42
}
catch (int e) {
    // Gestisco l'eccezione di tipo int
    std::cout << "Eccezione di tipo int catturata: " << e << std::endl;
}
catch (const char* e) {
    // Gestisco l'eccezione di tipo const char*
    std::cout << "Eccezione di tipo const char* catturata: " << e << std::endl;
}

In questo esempio, abbiamo aggiunto un secondo blocco catch che cattura un’eccezione di tipo const char* e ne gestisce il messaggio.

L’uso di Classi di Eccezioni Personalizzate

Spesso, è utile definire classi di eccezioni personalizzate per rappresentare errori specifici nel proprio programma. Queste classi possono contenere informazioni aggiuntive sull’errore e possono essere lanciate e catturate in modo più specifico. Ad esempio:

#include <iostream>
#include <stdexcept>

class MiaEccezione : public std::runtime_error {
public:
    MiaEccezione(const std::string& messaggio) : std::runtime_error(messaggio) {}
};

int main() {
    try {
        // Codice che potrebbe generare un'eccezione personalizzata
        throw MiaEccezione("Si è verificato un errore personalizzato.");
    }
    catch (const MiaEccezione& e) {
        // Gestisco l'eccezione personalizzata
        std::cout << "Eccezione personalizzata catturata: " << e.what() << std::endl;
    }
    return 0;
}

In questo esempio, abbiamo definito una classe di eccezione personalizzata MiaEccezione che eredita da std::runtime_error. Questa classe può essere utilizzata per lanciare eccezioni più informative e specifiche.

L’uso del Blocco finally

In C++, non esiste un blocco finally come in alcuni altri linguaggi. Tuttavia, è possibile ottenere un comportamento simile utilizzando oggetti con una durata di vita basata su stack (ad esempio, oggetti automatici o risorse gestite dalla classe). L’oggetto può essere distrutto alla fine del blocco try o catch, consentendo di eseguire azioni di pulizia o di rilascio delle risorse in modo affidabile.

Conclusioni

La gestione delle eccezioni è uno strumento potente per affrontare errori e situazioni eccezionali in modo sicuro e strutturato in C++. Consente di separare la logica di gestione degli errori dalla logica principale del programma, migliorando la robustezza e la manutenibilità del codice. È possibile definire eccezioni personalizzate per rappresentare errori specifici e gestirli in modo specifico. Utilizza la gestione delle eccezioni per scrivere codice che possa affrontare in modo efficace situazioni impreviste durante l’esecuzione.