Manejo de excepciones en POO
Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 81 de 104.
El manejo de excepciones en C++ proporciona una forma estructurada de detectar y responder a errores en tiempo de ejecución. En la programación orientada a objetos, las excepciones se integran de forma natural con las jerarquías de clases, lo que te permite crear tipos de error significativos que aportan contexto sobre lo que salió mal.
El mecanismo básico usa tres palabras clave: try, throw y catch. El código que podría fallar va en un bloque try, los errores se señalan con throw y los bloques catch gestionan tipos de excepción específicos:
#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 biblioteca estándar de C++ proporciona una jerarquía de clases de excepción cuya raíz es std::exception. Entre las clases derivadas más comunes están std::runtime_error para problemas en tiempo de ejecución y std::logic_error para errores de programación. Todas las excepciones estándar proporcionan un método what() que devuelve un mensaje de error.
Cuando se lanza una excepción, la pila se desenrolla: se llama a los destructores de todos los objetos locales mientras el programa busca un bloque catch coincidente. Esto garantiza una limpieza adecuada incluso cuando se producen errores, por lo que RAII y el manejo de excepciones funcionan tan bien juntos.
Desafío
FácilConstruyamos una calculadora de división segura que demuestre el manejo de excepciones en un contexto orientado a objetos. Crearás una clase Calculator que realiza operaciones de división y lanza excepciones significativas cuando algo sale mal; después, manejarás esas excepciones de forma adecuada en tu programa principal.
Organizarás el código en tres archivos:
Calculator.h: Define tu claseCalculator, que realiza operaciones matemáticas con un manejo adecuado de errores.Tu clase
Calculatordebe tener un métododivide(double numerator, double denominator)que devuelva el resultado de la división. Sin embargo, si el denominador es cero, debe lanzar unstd::runtime_errorcon el mensajeDivision by zero. Si el numerador o el denominador es negativo, debe lanzar unstd::invalid_argumentcon el mensajeNegative values not allowed.Incluye también un método
safeSqrt(double value)que devuelva la raíz cuadrada del valor. Si el valor es negativo, lanza unstd::runtime_errorcon el mensajeCannot compute square root of negative number. Tendrás que incluir<cmath>para usar la funciónsqrt.Calculator.cpp: Implementa los métodos declarados en el archivo de encabezado. Asegúrate de incluir los encabezados necesarios (<stdexcept>y<cmath>) y de comprobar las condiciones antes de realizar las operaciones.main.cpp: Lee tres entradas (cada una en una línea distinta):- Tipo de operación:
divideosqrt - Primer número (double)
- Segundo número (double): se usa solo para la división; se ignora para sqrt
Crea un objeto
Calculatory realiza la operación solicitada dentro de un bloque try. Si la operación se realiza correctamente, imprimeResult: [value]. Si se captura una excepción, imprimeError: [message], donde el mensaje se obtiene del métodowhat()de la excepción.Después del bloque try-catch (independientemente de si se produjo una excepción), imprime
Calculation completepara demostrar que el programa continúa ejecutándose después de manejar las excepciones.- Tipo de operación:
Por ejemplo, con las entradas divide, 10 y 2:
Result: 5
Calculation completeCon las entradas divide, 10 y 0:
Error: Division by zero
Calculation completeCon las entradas divide, -5 y 2:
Error: Negative values not allowed
Calculation completeCon las entradas sqrt, 16 y 0:
Result: 4
Calculation completeCon las entradas sqrt, -9 y 0:
Error: Cannot compute square root of negative number
Calculation completeObserva cómo el programa maneja los errores de forma adecuada al capturar las excepciones y mostrar mensajes significativos, y luego continúa ejecutándose. Este patrón mantiene limpio el manejo de errores y permite que la lógica principal se centre en el flujo normal.
Pruébalo tú mismo
#include <iostream>
#include <string>
#include "Calculator.h"
using namespace std;
int main() {
// Lee las entradas
string operation;
double num1, num2;
cin >> operation;
cin >> num1;
cin >> num2;
// Crea un objeto Calculator
Calculator calc;
// TODO: Usa un bloque try-catch para realizar la operación
// - Si operation es "divide", llama a calc.divide(num1, num2)
// - Si operation es "sqrt", llama a calc.safeSqrt(num1)
// - Si se realiza correctamente, imprime "Result: " seguido del resultado
// - Captura las excepciones e imprime "Error: " seguido del mensaje de la excepción (usa what())
// - Después del bloque try-catch, imprime siempre "Calculation complete"
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