Gestione delle eccezioni in OOP

Fa parte della sezione Programmazione orientata agli oggetti del percorso C++ di Coddy. Lezione 81 di 104.

La gestione delle eccezioni in C++ fornisce un modo strutturato per rilevare e gestire gli errori in fase di esecuzione. Nella programmazione orientata agli oggetti, le eccezioni si integrano naturalmente con le gerarchie di classi, permettendoti di creare tipi di errore significativi che forniscono informazioni sul problema che si è verificato.

Il meccanismo di base usa tre parole chiave: try, throw e catch. Il codice che potrebbe non riuscire va in un blocco try, gli errori vengono segnalati con throw e i blocchi catch gestiscono tipi specifici di eccezioni:

#include <iostream>
#include <stdexcept>

class BankAccount {
    double balance;
public:
    BankAccount(double b) : balance(b) {}
    
    void withdraw(double amount) {
        if (amount > balance) {
            throw std::runtime_error("Insufficient funds");
        }
        balance -= amount;
    }
    
    double getBalance() const { return balance; }
};

int main() {
    BankAccount account(100.0);
    
    try {
        account.withdraw(150.0);
    } catch (const std::runtime_error& e) {
        std::cout << "Error: " << e.what() << "\n";
    }
    
    std::cout << "Balance: " << account.getBalance() << "\n";
}

La libreria standard C++ fornisce una gerarchia di classi di eccezioni che ha come radice std::exception. Tra le classi derivate più comuni ci sono std::runtime_error per i problemi di runtime e std::logic_error per gli errori di programmazione. Tutte le eccezioni standard forniscono un metodo what() che restituisce un messaggio di errore.

Quando viene lanciata un'eccezione, lo stack si svolge: vengono chiamati i distruttori di tutti gli oggetti locali mentre il programma cerca un blocco catch corrispondente. Questo garantisce una corretta pulizia anche quando si verificano errori, ed è per questo che RAII e la gestione delle eccezioni funzionano così bene insieme.

Sfida

Facile

Costruiamo una calcolatrice con divisione sicura che dimostra la gestione delle eccezioni in un contesto orientato agli oggetti. Creerai una classe Calculator che esegue operazioni di divisione e genera eccezioni significative quando qualcosa va storto, poi gestirai queste eccezioni in modo appropriato nel programma principale.

Organizzerai il codice in tre file:

Calculator.h: Definisci la classe Calculator, che esegue operazioni matematiche con una corretta gestione degli errori.
La classe Calculator dovrebbe avere un metodo divide(double numerator, double denominator) che restituisce il risultato della divisione. Tuttavia, se il denominatore è zero, dovrebbe generare una std::runtime_error con il messaggio Division by zero. Se il numeratore o il denominatore è negativo, dovrebbe generare una std::invalid_argument con il messaggio Negative values not allowed.

Includi anche un metodo safeSqrt(double value) che restituisce la radice quadrata del valore. Se il valore è negativo, genera una std::runtime_error con il messaggio Cannot compute square root of negative number. Dovrai includere <cmath> per la funzione sqrt.
Calculator.cpp: Implementa i metodi dichiarati nel file header. Assicurati di includere gli header necessari (<stdexcept> e <cmath>) e di controllare le condizioni prima di eseguire le operazioni.
main.cpp: Leggi tre input (ciascuno su una riga separata):
1. Tipo di operazione: divide oppure sqrt
2. Primo numero (double)
3. Secondo numero (double): usato solo per la divisione, ignorato per sqrt
Crea un oggetto Calculator ed esegui l'operazione richiesta all'interno di un blocco try. Se l'operazione riesce, stampa Result: [value]. Se viene catturata un'eccezione, stampa Error: [message], dove il messaggio proviene dal metodo what() dell'eccezione.

Dopo il blocco try-catch (indipendentemente dal fatto che si sia verificata un'eccezione), stampa Calculation complete per dimostrare che il programma continua a essere eseguito dopo aver gestito le eccezioni.

Per esempio, con gli input divide, 10 e 2:

Result: 5
Calculation complete

Con gli input divide, 10 e 0:

Error: Division by zero
Calculation complete

Con gli input divide, -5 e 2:

Error: Negative values not allowed
Calculation complete

Con gli input sqrt, 16 e 0:

Result: 4
Calculation complete

Con gli input sqrt, -9 e 0:

Error: Cannot compute square root of negative number
Calculation complete

Nota come il programma gestisce gli errori in modo appropriato, catturando le eccezioni e visualizzando messaggi significativi, quindi continua l'esecuzione. Questo approccio mantiene pulita la gestione degli errori e permette alla logica principale di concentrarsi sul percorso senza errori.

Provalo tu

#include <iostream>
#include <string>
#include "Calculator.h"

using namespace std;

int main() {
    // Leggi gli input
    string operation;
    double num1, num2;
    
    cin >> operation;
    cin >> num1;
    cin >> num2;
    
    // Crea un oggetto Calculator
    Calculator calc;
    
    // TODO: Usa un blocco try-catch per eseguire l'operazione
    // - Se operation è "divide", chiama calc.divide(num1, num2)
    // - Se operation è "sqrt", chiama calc.safeSqrt(num1)
    // - Se l'operazione riesce, stampa "Result: " seguito dal risultato
    // - Intercetta le eccezioni e stampa "Error: " seguito dal messaggio dell'eccezione (usa what())
    // - Dopo il blocco try-catch, stampa sempre "Calculation complete"
    
    
    return 0;
}