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
ystd::runtime_error
se capturan en bloquescatch
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
Manejo de excepciones en operaciones de E/S
En este ejemplo, utilizamos try-catch
para manejar excepciones relacionadas con la lectura de un archivo.
Capturamos dos tipos de excepciones: std::ios_base::failure
si hay un error de E/S, y std::exception
para otros problemas generales.
#include <iostream>
#include <fstream>
#include <stdexcept>
int main() {
try {
std::ifstream archivo("archivo.txt");
if (!archivo) {
throw std::ios_base::failure("Error: No se puede abrir el archivo.");
}
std::string linea;
while (std::getline(archivo, linea)) {
std::cout << linea << std::endl;
}
}
catch (const std::ios_base::failure& e) {
std::cout << "Error de archivo: " << e.what() << std::endl;
}
catch (const std::exception& e) {
std::cout << "Error general: " << e.what() << std::endl;
}
return 0;
}
Este código intenta leer un archivo y, si ocurre un error al abrirlo o durante la lectura, captura la excepción y muestra un mensaje en la consola.