Biblioteca estándar de C++<exception>

En la programación en C++, el manejo de excepciones es un mecanismo importante de manejo de errores que permite al programa manejar estos errores con elegancia, en lugar de hacer que el programa se bloquee.

En C++, el manejo de excepciones normalmente se implementa utilizando las palabras clave try, catch y throw. La biblioteca estándar proporciona la clase std::exception y sus clases derivadas para manejar excepciones.

En la biblioteca estándar de C++, el<exception>archivo de cabecera proporciona un conjunto de infraestructura para el manejo de excepciones, incluyendo clases de excepción, mecanismos de manejo de excepciones, etc.

Una excepción es un evento que ocurre durante la ejecución del programa e interrumpe el flujo normal de instrucciones. En C++, una excepción puede ser un objeto de cualquier tipo, pero normalmente es un objeto de una clase de excepción. La biblioteca estándar de C++ define algunas clases de excepción básicas, comostd::exception、std::bad_alloc、std::bad_castetc.

Puede ampliar la funcionalidad del manejo de excepciones definiendo sus propias clases de excepción, o utilizar las clases de excepción existentes en la biblioteca estándar para manejar situaciones de excepción comunes.

Sintaxis

Lanzar excepciones

En C++, se utiliza la palabra clave throw para lanzar una excepción, la sintaxis es la siguiente:

throw exception_object;

Capturar excepciones

Utilice las palabras clave try y catch para capturar y manejar excepciones, la sintaxis es la siguiente:

try {
    // 可能抛出异常的代码
} catch (exception_type e) {
    // 处理异常的代码
}

Puede especificar el tipo de excepción a capturar, o utilizar un bloque catch genérico para capturar todos los tipos de excepciones:

try {
    // 可能会抛出异常的代码
} catch (const std::exception& e) {
    // 处理 std::exception 及其派生类的异常
} catch (...) {
    // 处理所有其他类型的异常
}

std::exception

std::exception es la clase base definida en la biblioteca estándar de C++, utilizada como base para todas las clases de excepción estándar. Define algunas funciones virtuales, como what(), que se utilizan para devolver una cadena de caracteres al estilo C con información sobre la excepción.

class exception {
public:
    virtual const char* what() const noexcept;
};

Clases de excepción estándar

La biblioteca estándar de C++ proporciona varias clases de excepción derivadas de std::exception, como std::runtime_error, std::logic_error, etc., que se utilizan para representar situaciones de excepción comunes. Puede elegir la clase adecuada según la situación de excepción específica.

throw std::runtime_error("Runtime error occurred");
throw std::logic_error("Logic error occurred");

Ejemplo

A continuación se muestra un ejemplo simple que utiliza el<exception>archivo de cabecera, que demuestra cómo lanzar y capturar excepciones.

Resultado de salida:

Caught an exception: My custom exception

Clases de excepción

En C++, la biblioteca estándar proporciona algunas clases de excepción comunes, todas ellas heredan destd::exception, y se pueden#include <stdexcept>incluir para su uso.

A continuación se presentan algunas clases de excepción comunes de C++ y sus usos principales:

• std::exception: La clase base de todas las clases de excepción estándar, define la interfaz básica de las excepciones. Tiene una función virtualwhat(), utilizada para devolver una cadena de caracteres al estilo C con información sobre la excepción.

• std::runtime_error: Representa errores en tiempo de ejecución, normalmente excepciones causadas por problemas de lógica del programa, como parámetros no válidos, imposibilidad de abrir archivos, etc.

  throw std::runtime_error("Runtime error occurred");

• std::logic_error: Representa errores lógicos, normalmente excepciones causadas por errores de lógica del programa, como fallos de aserción lógica, índice fuera de límites, etc.

   throw std::logic_error("Logic error occurred");

• std::invalid_argument: Representa que los argumentos pasados a una función no son válidos.

  throw std::invalid_argument("Invalid argument");

• std::out_of_range: Representa el acceso a objetos fuera del rango válido, como matrices, contenedores, etc.

  throw std::out_of_range("Out of range");
  

• std::overflow_errorystd::underflow_error: Representa desbordamiento o subdesbordamiento en el cálculo numérico.

  throw std::overflow_error("Overflow occurred");
  throw std::underflow_error("Underflow occurred");
  

• std::bad_alloc: Representa un fallo en la asignación de memoria.

  throw std::bad_alloc();  // 内存分配失败时抛出
  

Salida:

Memory allocation failed: std::bad_alloc

Consideraciones

• Las excepciones no deben utilizarse para el flujo de control normal; solo deben utilizarse para manejar situaciones excepcionales.
• El manejo de excepciones puede afectar al rendimiento del programa, por lo que debe utilizarse con precaución.
• Asegúrese de que en elcatchbloque se manejen todos los tipos de excepción posibles, para evitar que el programa se bloquee debido a excepciones no manejadas.

Al utilizar el<exception>archivo de cabecera, los programadores de C++ pueden manejar las situaciones de error en los programas de manera más eficaz, mejorando la robustez y fiabilidad del programa.