Cosa sono le eccezioni in C++?

Meccanismo di gestione delle situazioni anomale (errori) che si verificano durante l'esecuzione del programma. Permette di separare il codice responsabile della logica del programma dal codice di gestione degli errori.

Parole chiave:

• try: Definisce un blocco di codice in cui possono verificarsi eccezioni.
• catch: Definisce un blocco di codice che viene eseguito quando si verifica un tipo specifico di eccezione.
• throw: Genera (crea) un'eccezione. Il tipo di eccezione può essere qualsiasi oggetto.

Principio di funzionamento:

1. Il codice che può causare un errore viene inserito nel blocco try.
2. Se nel blocco try si verifica un'eccezione (generata con throw), l'esecuzione normale del programma viene interrotta.
3. Il sistema cerca un blocco catch appropriato in grado di gestire l'eccezione generata (per tipo).
4. Se viene trovato un catch corrispondente, il suo codice viene eseguito.
5. Se non viene trovato un catch appropriato al livello corrente di chiamata, l'eccezione si "propaga" verso l'alto nello stack di chiamate fino a trovare una funzione di gestione adeguata (o il programma termina in modo errato).

Esempio:

#include <iostream>
#include <stdexcept> // Per tipi di eccezioni standard

int divide(int a, int b) {
    if (b == 0) {
        throw std::runtime_error("Divisione per zero!"); // Genera un'eccezione
    }
    return a / b;
}

int main() {
    try {
        int result = divide(10, 0); // Chiama funzione che può lanciare eccezione
        std::cout << "Risultato: " << result << std::endl; // Questa riga non verrà eseguita
    } catch (const std::runtime_error& e) { // Cattura eccezione di tipo std::runtime_error
        std::cerr << "Errore: " << e.what() << std::endl; // Gestisce l'eccezione
    } catch (...) { // Cattura qualsiasi altra eccezione (puntini)
        std::cerr << "Si è verificato un errore sconosciuto." << std::endl;
    }

    std::cout << "Il programma continua dopo la gestione dell'errore." << std::endl;
    return 0;
}

Vantaggi:

• Separazione tra logica e gestione degli errori.
• Semplificazione del flusso principale del codice.
• Possibilità di gestire errori a diversi livelli della gerarchia di chiamate.

Svantaggi:

• Potrebbe influire sulle prestazioni (a causa della propagazione dello stack).
• Difficoltà nel comprendere il flusso di esecuzione con molteplici eccezioni.
• Un uso scorretto può portare a perdite di risorse (se le risorse non vengono rilasciate correttamente in caso di eccezione).

Per lavorare in modo sicuro con le risorse in presenza di eccezioni, si utilizzano spesso RAII (Resource Acquisition Is Initialization) e puntatori intelligenti.