Manejo de excepciones en C++: Guía práctica con try, catch, throw

¿Qué es el manejo de excepciones en C++?

El manejo de excepciones permite a los programas C++ recuperarse elegantemente de errores inesperados en tiempo de ejecución. Cuando ocurre un error, el control salta a un manejador especial que decide cómo responder.

Al encerrar código potencialmente problemático dentro de un bloque try y seguirlo con una o más cláusulas catch, brinda al programa una ruta clara para gestionar condiciones excepcionales.

Si no se lanza ninguna excepción, el bloque try se ejecuta normalmente y los manejadores se omiten.

En este tutorial aprenderá:

• Qué es el manejo de excepciones y por qué importa
• Las palabras clave principales: throw, catch, try
• Sintaxis y patrones comunes
• Excepciones estándar definidas por la Biblioteca Estándar de C++
• Cómo crear y usar excepciones definidas por el usuario

¿Por qué manejo de excepciones?

El manejo de excepciones ofrece varios beneficios tangibles:

• Separa la lógica de manejo de errores del código regular, mejorando legibilidad y mantenibilidad.
• Permite que las funciones expongan solo las excepciones que les importan; los llamadores pueden manejar el resto.

Palabras clave del manejo de excepciones

Tres palabras clave forman la columna vertebral del manejo de excepciones en C++:

• throw – señala una condición de error creando un objeto de excepción.
• catch – intercepta una excepción y proporciona código para reaccionar a ella.
• try – marca la región de código que puede lanzar excepciones.

El código dentro del bloque try se llama código protegido; si lanza, se ejecuta el bloque catch correspondiente.

Sintaxis

 try {
    // código protegido
} catch (NombreExcepción excepción1) {
    // manejar excepción1
} catch (NombreExcepción excepción2) {
    // manejar excepción2
} // ... más bloques catch 

• Un solo try puede ir seguido de múltiples cláusulas catch.
• El tipo en cada cláusula catch especifica la excepción a capturar.
• Dentro de un catch, la excepción capturada puede referenciarse por el identificador elegido.

Ejemplo 1: Acceso a elemento de vector fuera de rango

#include<iostream>
#include<vector>
using namespace std;
int main() {
    vector<int> vec;
    vec.push_back(0);
    vec.push_back(1);
    try {
        vec.at(2); // fuera de rango
    } catch (exception& ex) {
        cout << "¡Ocurrió una excepción!" << endl;
    }
    return 0;
} 

Salida:

Captura del código:

Desglose del código:

1. Incluya iostream y vector para E/S y contenedores.
2. Use el espacio de nombres std para evitar nombres completamente calificados.
3. Instancie un vector<int> y pueblelo.
4. Intente acceder a un elemento fuera de los límites dentro de un bloque try.
5. Capture la excepción estándar std::exception y muestre un mensaje.
6. Retorne desde main.

Ejemplo 2: Manejo de división por cero

#include <iostream>
using namespace std;
double divisionCero(int x, int y) {
    if (y == 0) {
        throw "¡División por cero!";
    }
    return static_cast(x) / y;
}
int main() {
    int a = 11;
    int b = 0;
    double c = 0;
    try {
        c = divisionCero(a, b);
        cout << c << endl;
    } catch (const char* mensaje) {
        cerr << mensaje << endl;
    }
    return 0;
} 

Salida:

Captura del código:

Desglose del código:

1. Defina divisionCero que lanza una cadena C cuando se divide por cero.
2. Llame a la función dentro de un bloque try e imprima el resultado.
3. Capture la excepción de cadena y muestre un mensaje de error.

Excepciones estándar de C++

La Biblioteca Estándar declara una rica jerarquía de excepciones en <exception>. A continuación, las más usadas:

Excepción	Descripción
std::exception	Clase base para todas las excepciones estándar.
std::bad_alloc	Lanzada por new en fallo de asignación.
std::bad_cast	Lanzada por dynamic_cast cuando un cast falla.
std::bad_exception	Usada para señalar una excepción inesperada.
std::bad_typeid	Lanzada por typeid en glvalue de tipo polimórfico nulo.
std::logic_error	Errores detectables por el programador.
std::domain_error	Dominio inválido para función matemática.
std::invalid_argument	Función recibió argumento inválido.
std::length_error	Intento de crear cadena demasiado grande.
std::out_of_range	Lanzada por vector::at cuando índice fuera de límites.
std::runtime_error	Errores en tiempo de ejecución no capturados por otras categorías.
std::overflow_error	Desbordamiento matemático ocurrido.
std::range_error	Valor fuera de rango para la operación.
std::underflow_error	Subdesbordamiento matemático ocurrido.

Excepciones definidas por el usuario

La clase base std::exception puede extenderse para crear tipos de error específicos del dominio. Sobrescribir what() proporciona un mensaje descriptivo.

Ejemplo: Excepción personalizada

#include <iostream>
#include <exception>
using namespace std;
class NuevaExcepcion : public exception {
public:
    const char* what() const noexcept override {
        return "Ocurrió nuevaExcepcion";
    }
} newex;
int main() {
    try {
        throw newex;
    } catch (exception& ex) {
        cout << ex.what() << '\n';
    }
    return 0;
} 

Salida:

Captura del código:

Desglose del código:

1. Derive NuevaExcepcion de std::exception y sobrescriba what().
2. Instancie un objeto newex para lanzar.
3. Lance newex dentro de un bloque try.
4. Capture por referencia a std::exception e imprima el mensaje vía what().

Conclusiones

• El manejo de excepciones es esencial para aplicaciones C++ robustas que deben recuperarse de errores en tiempo de ejecución.
• Use try para proteger código, catch para responder y throw para señalar problemas.
• Aproveche el rico conjunto de excepciones estándar, y extienda std::exception cuando se necesiten tipos de error personalizados.
• Mantenga la lógica de manejo de errores separada de la lógica de negocio para código más limpio y mantenible.