C++ Manejo de excepciones

Las excepciones son problemas que surgen durante la ejecución de un programa. Las excepciones de C++ se refieren a situaciones especiales que ocurren en tiempo de ejecución, como intentar dividir por cero.

Las excepciones proporcionan una forma de transferir el control del programa. El manejo de excepciones en C++ involucra tres palabras clave:try、catch、throw。

  • throw:Cuando surge un problema, el programa lanza una excepción. Esto se hace mediante el uso dethrowla palabra clave.
  • catch:En el lugar donde desee manejar el problema, capture la excepción mediante un controlador de excepciones.catchLa palabra clave se utiliza para capturar excepciones.
  • try: tryEl código en el bloque identifica la excepción específica que se activará. Suele ir seguido de uno o más bloques catch.

Si un bloque lanza una excepción, el método para capturar la excepción utiliza latryycatchpalabra clave. En el bloque try se coloca el código que puede lanzar excepciones; el código dentro del bloque try se denomina código protegido. La sintaxis de la declaración try/catch es la siguiente:

try { // Código protegido }catch( ExceptionName e1 ) { // Bloque catch }catch( ExceptionName e2 ) { // Bloque catch }catch( ExceptionName eN ) { // Bloque catch }

Sitryel bloque lanza diferentes excepciones en diferentes situaciones, en este caso puede intentar enumerar múltiplescatchdeclaraciones para capturar diferentes tipos de excepciones.

Lanzar excepciones

Puede utilizar lathrowdeclaración para lanzar una excepción en cualquier lugar de un bloque de código. El operando de la declaración throw puede ser cualquier expresión; el tipo del resultado de la expresión determina el tipo de excepción lanzada.

A continuación se muestra un ejemplo de cómo lanzar una excepción al intentar dividir por cero:

double division(int a, int b) { if( b == 0 ) { throw "Division by zero condition!"; } return (a/b); }

Capturar excepciones

catchEl bloque catch sigue altrybloque try, y se utiliza para capturar excepciones. Puede especificar el tipo de excepción que desea capturar, lo cual está determinado por la declaración de excepción entre paréntesis después de la palabra clave catch.

try { // Código protegido }catch( ExceptionName e ) { // Código para manejar la excepción ExceptionName }

El código anterior capturará una excepción de tipoExceptionName. Si desea que el bloque catch pueda manejar cualquier tipo de excepción lanzada por el bloque try, debe usar puntos suspensivos ... dentro de los paréntesis de la declaración de excepción, como se muestra a continuación:

try { // Código protegido }catch(...) { // Código que puede manejar cualquier excepción }

A continuación se muestra un ejemplo que lanza una excepción de división por cero y la captura en un bloque catch.

Ejemplo

#include <iostream> using namespace std; double division(int a, int b) { if( b == 0 ) { throw "Division by zero condition!"; } return (a/b); } int main () { int x = 50; int y = 0; double z = 0; try { z = division(x, y); cout << z << endl; }catch (const char* msg) { cerr << msg << endl; } return 0; }

Dado que hemos lanzado una excepción de tipoconst char*, al capturar dicha excepción debemos usar const char* en el bloque catch. Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Division by zero condition!

Excepciones estándar de C++

C++ proporciona una serie de excepciones estándar, definidas en<exception>, que podemos utilizar en los programas. Estas excepciones estándar están organizadas en una jerarquía de clases padre-hijo, como se muestra a continuación:

C++ 异常的层次结构

La siguiente tabla describe cada una de las excepciones que aparecen en la jerarquía anterior:

Excepción Descripción
std::exception Esta excepción es la clase padre de todas las excepciones estándar de C++.
std::bad_alloc Esta excepción puede ser por medio denewlanzada.
std::bad_cast Esta excepción puede ser por medio dedynamic_castlanzada.
std::bad_typeid Esta excepción puede ser por medio detypeidlanzada.
std::bad_exception Esto es muy útil al manejar excepciones inesperadas en programas de C++.
std::logic_error Excepciones que, en teoría, pueden detectarse mediante la lectura del código.
std::domain_error Esta excepción se lanza cuando se utiliza un dominio matemático no válido.
std::invalid_argument Esta excepción se lanza cuando se utiliza un argumento no válido.
std::length_error Esta excepción se lanza cuando se crea un std::string demasiado largo.
std::out_of_range Esta excepción puede ser lanzada por métodos como std::vector y std::bitset<>::operator[]().
std::runtime_error Excepciones que, en teoría, no pueden detectarse mediante la lectura del código.
std::overflow_error Esta excepción se lanza cuando ocurre un desbordamiento matemático (overflow).
std::range_error Esta excepción se lanza cuando se intenta almacenar un valor fuera de rango.
std::underflow_error Esta excepción se lanza cuando ocurre un desbordamiento matemático por subflujo (underflow).

Definir nuevas excepciones

Puede, mediante herencia y sobrecarga de laexceptionclase, definir nuevas excepciones. El siguiente ejemplo demuestra cómo usar la clase std::exception para implementar sus propias excepciones:

Ejemplo

#include <iostream> #include <exception> using namespace std; struct MyException : public exception { const char * what () const throw () { return "C++ Exception"; } }; int main() { try { throw MyException(); } catch(MyException& e) { std::cout << "MyException caught" << std::endl; std::cout << e.what() << std::endl; } catch(std::exception& e) { // Otros errores } }

Esto producirá el siguiente resultado:

MyException caught
C++ Exception

Aquí,what()es un método público proporcionado por la clase de excepción y ha sido sobrecargado por todas las subclases de excepción. Devuelve la causa de la excepción.

Otras extensiones