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.
Desafío
FácilVamos 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
FileExceptionque herede destd::exception. Debe almacenar un mensaje de error y sobrescribir el métodowhat()con el especificadornoexcept.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 claseFileProcessorque simule operaciones con archivos y lance tus excepciones personalizadas.Tu
FileProcessordebe tener un métodoopenFile(const std::string& filename)que simule la apertura de un archivo:- Si el nombre del archivo contiene
missing, lanza unaFileNotFoundException - Si el nombre del archivo contiene
locked, lanza unaPermissionDeniedException - En caso contrario, devuelve la cadena
Successfully opened: [filename]
- Si el nombre del archivo contiene
main.cpp: Lee un único nombre de archivo de la entrada.Crea un
FileProcessore intenta abrir el archivo. Usa un bloque try-catch con controladores ordenados del más específico al más general:- Captura
FileNotFoundExceptione imprime:File Error: [message] - Captura
PermissionDeniedExceptione imprime:Access Error: [message] - Captura
FileExceptione imprime:General File Error: [message]
Si no se lanza ninguna excepción, imprime el mensaje de éxito devuelto por
openFile().- Captura
Por ejemplo, con la entrada report.txt:
Successfully opened: report.txtCon la entrada missing_data.csv:
File Error: File not found: missing_data.csvCon la entrada locked_config.ini:
Access Error: Permission denied: locked_config.iniEste 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;
}
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
1Fundamentos de la POO
Archivos externosCompilación y construcción en C++Archivos de cabecera y archivos fuenteEspacios de nombres y ámbitoIntroducción a la POO en C++Clases y objetosEl puntero 'this'Métodos (funciones miembro)Atributos (miembros de datos)Fundamentos de constructores y destructoresRepaso: calculadora sencilla4Propiedades de clase
Miembros de instancia vs. estáticosGetters y settersFunciones miembro constPalabra clave mutableMétodos y variables estáticosFunciones y clases friendRepaso: gestor de cuentas bancarias7Herencia
Herencia básicaNiveles de acceso en la herenciaOrden de llamada de constructores y destructoresSobrescritura de métodosFunciones virtuales y VTableHerencia múltipleHerencia virtualRepaso: jerarquía de empleados2Gestión de memoria
Memoria de pila vs. heapPunteros y referenciasMemoria dinámica (new/delete)Punteros inteligentes en C++RAII en C++Repaso: gestor de arreglos dinámicos5Encapsulación
Especificadores de acceso en C++Especificadores de acceso en profundidadOcultación de informaciónStruct vs. classClases anidadas e internasRepaso: sistema de registros de estudiantes8Polimorfismo
Polimorfismo en compilación y en tiempo de ejecuciónSobrecarga de funcionesRepaso de las funciones virtualesFunciones virtuales purasClases abstractasDiseño de interfaces en C++Conversión dinámica y RTTIRepaso: calculadora de formas11Conceptos avanzados de POO
Composición frente a herenciaMixins mediante CRTPIdiom PimplBorrado de tiposClases enum y tipado fuerteManejo de excepciones en POOJerarquías de excepciones personalizadas14Patrones de diseño, parte 2
Patrón CommandPatrón AdapterPatrón DecoratorPatrón Template MethodPatrón StatePatrón CompositeRAII como patrón3Constructores y destructores
Constructor predeterminadoConstructor con parámetrosConstructor de copiaConstructor de movimientoListas de inicialización del constructorConstructores delegadosAnálisis detallado del destructorRegla de tres / cinco / ceroRepaso: clase String6Sobrecarga de operadores
Introducción a la sobrecarga de operadoresSobrecarga de operadores aritméticosSobrecarga de operadores de comparaciónOperadores de flujoSobrecarga del operador de asignaciónSobrecarga de los operadores [] y ()Operadores de conversión de tipoRepaso: clase Matrix9Plantillas
Plantillas de funcionesPlantillas de clasesEspecialización de plantillasPlantillas variádicasFundamentos de SFINAE y rasgos de tiposRepaso: contenedor genéricoPractica por tu cuenta: Compilador de C++ online