Menu
CoddyTech

Jerarquías de excepciones personalizadas

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 82 de 104.

Si bien la biblioteca estándar ofrece clases de excepción útiles como std::runtime_error, las aplicaciones del mundo real suelen beneficiarse de crear jerarquías de excepciones personalizadas. Al definir tus propias clases de excepción que heredan de excepciones estándar, puedes crear tipos de error específicos del dominio que aporten contexto adicional y permitan un manejo de errores más preciso.

Una clase de excepción personalizada suele heredar de std::exception o de una de sus clases derivadas y sobrescribe el método 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) {}
};

Esta jerarquía permite que los bloques catch manejen excepciones con distintos niveles de especificidad:

try {
    // operaciones de base de datos...
    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";
}

El especificador noexcept en what() es importante: garantiza que el método no lanzará excepciones, lo cual es un requisito de la interfaz de la clase base. Ordena los bloques catch de los más específicos a los más generales, ya que C++ utiliza el primer controlador que coincide.

challenge icon

Desafío

Fácil

Vamos a crear un sistema de procesamiento de archivos con una jerarquía de excepciones personalizada que gestione distintos tipos de errores relacionados con archivos. Crearás excepciones específicas del dominio que hereden de una clase de excepción base, lo que permitirá gestionar los errores con precisión en distintos niveles de especificidad.

Organizarás el código en tres archivos:

  • FileExceptions.h: Define tu jerarquía personalizada de excepciones para las operaciones con archivos.

    Crea una clase base FileException que herede de std::exception. Debe almacenar un mensaje de error y sobrescribir el método what() con el especificador noexcept.

    Después, crea dos clases de excepción derivadas:

    • FileNotFoundException: recibe un nombre de archivo y crea un mensaje: File not found: [filename]
    • PermissionDeniedException: recibe un nombre de archivo y crea un mensaje: Permission denied: [filename]

    Cada clase derivada debe llamar al constructor de su clase padre con el mensaje correspondiente.

  • FileProcessor.h: Define una clase FileProcessor que simule operaciones con archivos y lance tus excepciones personalizadas.

    Tu FileProcessor debe tener un método openFile(const std::string& filename) que simule la apertura de un archivo:

    • Si el nombre del archivo contiene missing, lanza una FileNotFoundException
    • Si el nombre del archivo contiene locked, lanza una PermissionDeniedException
    • En caso contrario, devuelve la cadena Successfully opened: [filename]
  • main.cpp: Lee un único nombre de archivo de la entrada.

    Crea un FileProcessor e intenta abrir el archivo. Usa un bloque try-catch con controladores ordenados del más específico al más general:

    1. Captura FileNotFoundException e imprime: File Error: [message]
    2. Captura PermissionDeniedException e imprime: Access Error: [message]
    3. Captura FileException e imprime: General File Error: [message]

    Si no se lanza ninguna excepción, imprime el mensaje de éxito devuelto por openFile().

Por ejemplo, con la entrada report.txt:

Successfully opened: report.txt

Con la entrada missing_data.csv:

File Error: File not found: missing_data.csv

Con la entrada locked_config.ini:

Access Error: Permission denied: locked_config.ini

Este desafío demuestra cómo las jerarquías de excepciones personalizadas te permiten gestionar los errores con el nivel de detalle adecuado: capturando excepciones específicas cuando necesitas una gestión precisa, o capturando la excepción base cuando quieres gestionar todos los errores de archivos de manera uniforme.

Pruébalo tú mismo

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

using namespace std;

int main() {
    string filename;
    cin >> filename;
    
    FileProcessor processor;
    
    // TODO: Usa un bloque try-catch para manejar las excepciones
    // Ordena los manejadores del más específico al más general:
    // 1. Captura FileNotFoundException - imprime: "File Error: [message]"
    // 2. Captura PermissionDeniedException - imprime: "Access Error: [message]"
    // 3. Captura FileException - imprime: "General File Error: [message]"
    // Si no hay ninguna excepción, imprime el mensaje de éxito de openFile()
    
    try {
        // TODO: Llama a processor.openFile() y maneja el resultado
        
    }
    // TODO: Añade bloques catch en orden del más específico al más general
    
    return 0;
}
quiz iconPonte a prueba

Esta lección incluye un breve cuestionario. Empieza la lección para responderlo y registrar tu progreso.

Todas las lecciones de Programación Orientada a Objetos

Practica por tu cuenta: Compilador de C++ online