cpp-bloque-try-catch

El bloque Try-Catch en C++

En C++, el bloque try-catch se utiliza para capturar y manejar excepciones (errores) que pueden ocurrir durante la ejecución de un programa.

Una excepción es un evento inesperado que interrumpe el flujo normal del programa. El objetivo del bloque try-catch es permitir al programa responder a errores de forma controlada, en lugar de finalizar de manera abrupta.

Estructura básica

La estructura básica de try-catch enes la siguiente:

try {
    // Código que puede lanzar una excepción
}
catch (const std::exception& e) {
    // Código para manejar la excepción
}
  • El bloque try contiene el código que podría generar una excepción.
  • El bloque catch captura la excepción y permite ejecutar un código para gestionarla.

Vamos a verlo con un ejemplo sencillo, en el que intentamos dividir dos números y manejamos una posible división por cero:

#include <iostream>
#include <stdexcept>

int main() {
    try {
        int divisor = 0;
        if (divisor == 0) {
            throw std::runtime_error("Error: División por cero no permitida.");
        }
        int resultado = 10 / divisor;
    }
    catch (const std::runtime_error& e) {
        std::cout << e.what() << std::endl;  // Muestra el mensaje de la excepción
    }
    return 0;
}

En este ejemplo, lanzamos una excepción std::runtime_error cuando divisor es cero. El bloque catch captura esta excepción e imprime un mensaje informativo.

Captura de múltiples excepciones

Puedes tener múltiples bloques catch para manejar diferentes tipos de excepciones de manera específica:

#include <iostream>
#include <stdexcept>

int main() {
    try {
        // Código que puede lanzar excepciones
        throw std::logic_error("Error lógico");
    }
    catch (const std::logic_error& e) {
        std::cout << "Capturado: " << e.what() << std::endl;
    }
    catch (const std::runtime_error& e) {
        std::cout << "Capturado: " << e.what() << std::endl;
    }
    catch (...) {
        std::cout << "Error desconocido" << std::endl;
    }
    return 0;
}

En este ejemplo:

  • std::logic_error y std::runtime_error se capturan en bloques catch específicos.

General catch

A veces, es útil tener un bloque catch que pueda manejar cualquier tipo de excepción. Esto se logra usando la sintaxis catch(...), que captura cualquier excepción sin importar su tipo.

try {
    throw 10.5;
} catch (...) {
    std::cerr << "Se ha capturado una excepción." << std::endl;
}

El uso de catch(...) es una manera de asegurarse de que cualquier excepción, sin importar su tipo, sea manejada.

Ejemplos Prácticos