Gerarchie personalizzate di eccezioni

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

Sebbene la libreria standard fornisca classi di eccezione utili come std::runtime_error, le applicazioni del mondo reale spesso traggono vantaggio dalla creazione di gerarchie di eccezioni personalizzate. Definendo le tue classi di eccezione che ereditano dalle eccezioni standard, puoi creare tipi di errore specifici del dominio che includono un contesto aggiuntivo e consentono una gestione degli errori più precisa.

Una classe di eccezione personalizzata eredita in genere da std::exception o da una delle sue classi derivate e sovrascrive il metodo what():

#include <exception>
#include <string>

class DatabaseException : public std::exception {
    std::string message;
public:
    DatabaseException(const std::string& msg) : message(msg) {}
    const char* what() const noexcept override { return message.c_str(); }
};

class ConnectionException : public DatabaseException {
public:
    ConnectionException(const std::string& host) 
        : DatabaseException("Failed to connect to: " + host) {}
};

class QueryException : public DatabaseException {
public:
    QueryException(const std::string& query) 
        : DatabaseException("Invalid query: " + query) {}
};

Questa gerarchia consente ai blocchi catch di gestire le eccezioni con diversi livelli di specificità:

try {
    // operazioni sul database...
    throw ConnectionException("localhost");
} catch (const ConnectionException& e) {
    std::cout << "Connection issue: " << e.what() << "\n";
} catch (const DatabaseException& e) {
    std::cout << "Database error: " << e.what() << "\n";
} catch (const std::exception& e) {
    std::cout << "General error: " << e.what() << "\n";
}

Lo specificatore noexcept su what() è importante: garantisce che il metodo non generi eccezioni, requisito dell’interfaccia della classe base. Ordina i blocchi catch dal più specifico al più generale, poiché C++ usa il primo gestore corrispondente.

Sfida

Facile

Costruiamo un sistema di elaborazione dei file con una gerarchia personalizzata di eccezioni che gestisce diversi tipi di errori relativi ai file. Creerai eccezioni specifiche del dominio che ereditano da una classe di eccezione di base, consentendo una gestione precisa degli errori a diversi livelli di specificità.

Organizzerai il codice in tre file:

FileExceptions.h: definisci la gerarchia personalizzata di eccezioni per le operazioni sui file.
Crea una classe di base FileException che eredita da std::exception. Dovrebbe memorizzare un messaggio di errore e sovrascrivere il metodo what() con lo specificatore noexcept.

Poi crea due classi di eccezione derivate:
- FileNotFoundException: accetta un nome file e crea un messaggio: File not found: [filename]
- PermissionDeniedException: accetta un nome file e crea un messaggio: Permission denied: [filename]
Ogni classe derivata dovrebbe chiamare il costruttore della classe genitore con il messaggio appropriato.
FileProcessor.h: definisci una classe FileProcessor che simula le operazioni sui file e genera le tue eccezioni personalizzate.
La classe FileProcessor dovrebbe avere un metodo openFile(const std::string& filename) che simula l'apertura di un file:
- Se il nome del file contiene missing, genera una FileNotFoundException
- Se il nome del file contiene locked, genera una PermissionDeniedException
- Altrimenti, restituisce la stringa Successfully opened: [filename]
main.cpp: leggi un singolo nome file dall'input.
Crea un FileProcessor e prova ad aprire il file. Usa un blocco try-catch con gestori ordinati dal più specifico al più generale:
1. Intercetta FileNotFoundException e stampa: File Error: [message]
2. Intercetta PermissionDeniedException e stampa: Access Error: [message]
3. Intercetta FileException e stampa: General File Error: [message]
Se non viene generata alcuna eccezione, stampa il messaggio di successo restituito da openFile().

Per esempio, con l'input report.txt:

Successfully opened: report.txt

Con l'input missing_data.csv:

File Error: File not found: missing_data.csv

Con l'input locked_config.ini:

Access Error: Permission denied: locked_config.ini

Questa sfida dimostra come le gerarchie personalizzate di eccezioni consentano di gestire gli errori con il livello di dettaglio appropriato: intercettando eccezioni specifiche quando serve una gestione precisa, oppure intercettando l'eccezione di base quando si desidera gestire tutti gli errori dei file in modo uniforme.

Provalo tu

#include <iostream>
#include <string>
#include "FileExceptions.h"
#include "FileProcessor.h"

using namespace std;

int main() {
    string filename;
    cin >> filename;
    
    FileProcessor processor;
    
    // TODO: Use a try-catch block to handle exceptions
    // Order handlers from most specific to most general:
    // 1. Catch FileNotFoundException - print: "File Error: [message]"
    // 2. Catch PermissionDeniedException - print: "Access Error: [message]"
    // 3. Catch FileException - print: "General File Error: [message]"
    // If no exception, print the success message from openFile()
    
    try {
        // TODO: Call processor.openFile() and handle the result
        
    }
    // TODO: Add catch blocks in order from most specific to most general
    
    return 0;
}