C++ Manejo de excepciones: ejemplo de prueba, captura y lanzamiento

Si ocurre una situación excepcional dentro de esa sección de código, se generará una excepción. A continuación, el controlador de excepciones tomará el control del programa.

En caso de que no ocurra ninguna circunstancia excepcional, el código se ejecutará normalmente. Los controladores serán ignorados.

En este C++ tutorial, aprenderás:

¿Por qué el manejo de excepciones?

A continuación se detallan los motivos para utilizar el manejo de excepciones en C++:

• Separarás el código de gestión de errores del código normal. El código será más legible y más fácil de mantener.
• Las funciones pueden manejar las excepciones que elijan. Incluso si una función genera muchas excepciones, solo manejará algunas. La persona que llama manejará las excepciones no detectadas.

Palabras clave de manejo de excepciones

Manejo de excepciones en C++ gira en torno a estas tres palabras clave:

• lanzar– cuando un programa encuentra un problema, lanza una excepción. La palabra clave throw ayuda al programa a realizar el lanzamiento.
• catch– un programa utiliza un controlador de excepciones para detectar una excepción. Se agrega a la sección de un programa donde necesita manejar el problema. Se hace usando la palabra clave catch.
• try– el bloque try identifica el bloque de código para el cual se activarán ciertas excepciones. Debe ir seguido de uno o más bloques de captura.

Supongamos que un bloque de código generará una excepción. La excepción será detectada mediante un método que utiliza palabras clave try y catch. El bloque try/catch debe rodear el código que pueda generar una excepción. Este código se conoce como código protegido.

Sintaxis

El try/catch toma esta sintaxis:

try {
   // the protected code
} catch( Exception_Name exception1 ) {
   // catch block
} catch( Exception_Name exception2 ) {
   // catch block
} catch( Exception_Name exceptionN ) {
   // catch block
}

• Aunque tenemos una declaración de prueba, podemos tener muchas declaraciones de captura.
• ExceptionName es el nombre de la excepción que se va a detectar.
• La excepción1, la excepción2 y la excepciónN son sus nombres definidos para referirse a las excepciones.

Ejemplo 1:

#include<iostream>
#include<vector>
using namespace std;

int main() {
	vector<int> vec;
	vec.push_back(0);	
	vec.push_back(1);	
	// access the third element, which doesn't exist
	try
	{
		vec.at(2);		
	}
	catch (exception& ex)
	{
		cout << "Exception occurred!" << endl;
	}
	return 0;
}

Salida:

Aquí hay una captura de pantalla del código:

Explicación del código:

1. Incluya el archivo de encabezado iostream en el programa para usar su funciones.
2. Incluya el archivo de encabezado vectorial en el programa para utilizar sus funciones.
3. Incluya el espacio de nombres estándar en el programa para sus clases sin llamarlo.
4. Llame a la función principal(). La lógica del programa debe agregarse dentro de su cuerpo.
5. Cree un vector llamado vec para almacenar datos enteros.
6. Agrega el elemento 0 al vector llamado vec.
7. Agrega el elemento 1 al vector llamado vec.
8. Un comentario. Será omitido por el C++ compilador.
9. Utilice la declaración try para detectar una excepción. El { marca el comienzo del cuerpo del bloque try/catch. El código agregado dentro del cuerpo se convertirá en el código protegido.
10. Intente acceder al elemento almacenado en el índice 2 (tercer elemento) del vector denominado vec. Este elemento no existe.
11. Fin del cuerpo del bloque try/catch.
12. Capte la excepción. El mensaje de error devuelto se almacenará en la variable ex.
13. Imprima algún mensaje en la consola si se detecta la excepción.
14. Fin del cuerpo del bloque de captura.
15. El programa debería devolver un valor tras una ejecución exitosa.
16. Fin del cuerpo de la función main().

Ejemplo 2:

#include <iostream>
using namespace std;
double zeroDivision(int x, int y) {

	if (y == 0) {
		throw "Division by Zero!";
	}
	return (x / y);
}

int main() {
	int a = 11;
	int b = 0;
	double c = 0;

	try {
		c = zeroDivision(a, b);
		cout << c << endl;
	}
	catch (const char* message) {
		cerr << message << endl;
	}
	return 0;
}

Salida:

Aquí hay una captura de pantalla del código:

Explicación del código:

1. Incluya el archivo de encabezado iostream en el programa para utilizar sus funciones.
2. Incluya el espacio de nombres estándar en el programa para sus clases sin llamarlo.
3. Cree una función denominada zeroDivision que acepte dos argumentos enteros, x e y. La función debe devolver un resultado doble.
4. Utilice una declaración if para verificar si el valor del argumento variable y es 0. { marca el comienzo del cuerpo if.
5. El mensaje que se devolverá/arrojará si y es 0.
6. Fin del cuerpo de la declaración if.
7. La función zeroDivision debería devolver el valor de x/y.
8. Fin del cuerpo de la función zeroDivision.
9. Llame al método principal(). El { marca el comienzo de este método.
10. Declarar una variable entera y asignarle el valor 11.
11. Declara una variable entera b y le asigna el valor 0.
12. Declarar una variable doble c y asignarle el valor 0.
13. Utilice la declaración try para detectar una excepción. El { marca el comienzo del cuerpo del bloque try/catch. El código agregado dentro del cuerpo se convertirá en el código protegido.
14. Llamar a la función zeroDivision y pasar como argumentos a y b, es decir, 11 y 0. El resultado de esta operación se almacenará en la variable c.
15. Imprima el valor de la variable c en la consola.
16. Fin del cuerpo del bloque try/catch.
17. Capte la excepción. El mensaje de error devuelto se almacenará en la variable mensaje.
18. Imprima el mensaje de error devuelto en la consola.
19. Fin del cuerpo del bloque de captura.
20. El programa debería devolver un valor tras una ejecución exitosa.
21. Fin del cuerpo de la función main().

C++ Excepciones estándar

C++ viene con una lista de excepciones estándar definidas en clase. Estos se describen a continuación:

Excepción	DESCRIPCIÓN
std :: excepción	Esta es una excepción y la clase principal de todos los estándares. C++ excepciones
std :: bad_alloc	Esta excepción la genera una nueva palabra clave.
std::bad_cast	Esta es una excepción lanzada por Dynamic_cast.
std::bad_exception	Un dispositivo útil para manejar excepciones inesperadas en C++ .
std::bad_typeid	Una excepción lanzada por typeid.
std::error_lógico	Esta excepción es teóricamente detectable leyendo el código.
std::dominio_error	Esta es una excepción lanzada después de usar un dominio matemáticamente no válido.
std::argumento_inválido	Se produce una excepción por utilizar argumentos no válidos.
std::longitud_error	Se produce una excepción después de crear un std::string grande.
estándar::fuera_de_rango	Lanzado por el método.
std :: runtime_error	Esta es una excepción que no se puede detectar leyendo el código.
std::overflow_error	Esta excepción se produce después de que se produce un desbordamiento matemático.
std::rango_error	Esta excepción se produce cuando intenta almacenar un valor fuera de rango.
std::underflow_error	Una excepción lanzada después de que se produjera un desbordamiento matemático.

Excepciones definidas por el usuario

El C++ La clase std::exception nos permite definir objetos que pueden lanzarse como excepciones. Esta clase ha sido definida en el encabezamiento. La clase nos proporciona una función miembro virtual llamada what.

Esta función devuelve una secuencia de caracteres terminada en nulo de tipo char *. Podemos sobrescribirlo en clases derivadas para tener una descripción de excepción.

Ejemplo:

#include <iostream>
#include <exception>
using namespace std;

class newException : public exception
{
	virtual const char* what() const throw()
	{
		return "newException occurred";
	}
} newex;

int main() {

	try {
		throw newex;
		}
	catch (exception& ex) {
		cout << ex.what() << '\n';
	}
	return 0;	
}

Salida:

Aquí hay una captura de pantalla del código:

Explicación del código:

1. Incluya el archivo de encabezado iostream en nuestro programa. Usaremos sus funciones sin obtener errores.
2. Incluya el archivo de encabezado de excepción en nuestro programa. Usaremos sus funciones como qué sin errores.
3. Incluya el espacio de nombres estándar en nuestro programa para usar sus clases sin llamarlo.
4. Cree una nueva clase llamada newException. Esta clase hereda la clase de excepción de C++.
5. El comienzo del cuerpo de clase.
6. Sobrescriba la función miembro virtual what() definida en el archivo de encabezado de excepción. Luego describiremos nuestra propia excepción, la nueva excepción.
7. Inicie la definición de la nueva excepción.
8. El mensaje que se devolverá si se detecta la nueva excepción.
9. Fin de la definición de la nueva excepción.
10. Fin del cuerpo de la clase newException. Newex es el nombre que se utilizará para detectar nuestra nueva excepción, después de lo cual se llamará a newException.
11. Llame a la función principal(). La lógica del programa debe agregarse dentro de su cuerpo. El { marca el comienzo de su cuerpo.
12. Utilice una declaración try para marcar el código dentro del cual necesitamos marcar la excepción. El { marca el comienzo del cuerpo del bloque try/catch. El código rodeado por esto quedará protegido.
13. Lanza la excepción newex si se detecta.
14. Fin del cuerpo del intento.
15. Utilice la declaración catch para detectar la excepción. El mensaje de error de excepción se almacenará en la variable ex.
16. Imprima el mensaje de error de excepción en la consola.
17. Fin del cuerpo de la declaración catch.
18. El programa debería devolver un valor si se ejecuta correctamente.
19. Fin del cuerpo de la función main().

Resumen

• Con manejo de excepciones en C++, puede manejar errores de tiempo de ejecución.
• Los errores de tiempo de ejecución son los errores que ocurren durante la ejecución del programa.
• El manejo de excepciones lo ayuda a manejar cualquier circunstancia inesperada en su programa.
• Cuando ocurre una circunstancia inesperada, el control del programa se transfiere a los controladores.
• Para detectar una excepción, coloque una sección de código debajo del bloque try-catch.
• La palabra clave throw ayuda al programa a lanzar excepciones, lo que ayuda al programa a manejar el problema.
• La palabra clave try ayuda a identificar el bloque de código para el cual se activarán ciertas excepciones.
• Podemos sobrescribir la función what() del archivo de encabezado de excepción para definir nuestras excepciones.