Manejo de excepciones de C++:ejemplo Try, Catch, throw

¿Qué es el manejo de excepciones en C++?

El manejo de excepciones en C++ le brinda una forma de manejar circunstancias inesperadas como errores de tiempo de ejecución. Entonces, cada vez que ocurre una circunstancia inesperada, el control del programa se transfiere a funciones especiales conocidas como controladores.

Para detectar las excepciones, coloca alguna sección de código bajo la inspección de excepciones. La sección de código se coloca dentro del bloque try-catch.

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

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

En este tutorial de C++, aprenderá:

• ¿Qué es el manejo de excepciones en C++?
• ¿Por qué manejar excepciones?
• Palabras clave de gestión de excepciones
• Sintaxis:
• Excepciones estándar de C++
• Excepciones definidas por el usuario

¿Por qué manejar excepciones?

Estas son las razones para usar el manejo de excepciones en C++:

• Separará su código de manejo de errores de su 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 arroja muchas excepciones, solo manejará algunas. La persona que llama manejará las excepciones no detectadas.

Palabras clave de gestión de excepciones

El 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.
• atrapar – un programa utiliza un controlador de excepciones para capturar una excepción. Se agrega a la sección de un programa donde necesita manejar el problema. Se hace usando la palabra clave catch.
• intentar – el bloque try identifica el bloque de código para el que se activarán ciertas excepciones. Debe ir seguido de uno o más bloques catch.

Supongamos que un bloque de código generará una excepción. La excepción será detectada por un método que utilice las palabras clave try y catch. El bloque try/catch debe rodear el código que puede generar una excepción. Dicho 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 a capturar.
• Excepción1, excepción2 y 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 sus funciones.
2. Incluya el archivo de encabezado de vector en el programa para usar sus funciones.
3. Incluya el espacio de nombres estándar en el programa a sus clases sin llamarlo.
4. Llama a la función main(). La lógica del programa debe agregarse dentro de su cuerpo.
5. Cree un vector llamado vec para almacenar datos enteros.
6. Agregue el elemento 0 al vector llamado vec.
7. Agregue el elemento 1 al vector llamado vec.
8. Un comentario. El compilador de C++ lo omitirá.
9. Utilice la instrucció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 llamado vec. Este elemento no existe.
11. Final del cuerpo del bloque try/catch.
12. Atrapa la excepción. El mensaje de error devuelto se almacenará en la variable ex.
13. Imprime algún mensaje en la consola si se detecta la excepción.
14. Final del cuerpo del bloque catch.
15. El programa debe devolver un valor después de 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 usar sus funciones.
2. Incluya el espacio de nombres estándar en el programa a sus clases sin llamarlo.
3. Cree una función llamada zeroDivision que tome dos argumentos enteros, x e y. La función debe devolver un resultado doble.
4. Use una instrucción if para verificar si el valor del argumento variable y es 0. El { marca el comienzo del cuerpo if.
5. El mensaje a ser devuelto/lanzado si y es 0.
6. Fin del cuerpo de la sentencia if.
7. La función zeroDivision debería devolver el valor de x/y.
8. Fin del cuerpo de la función zeroDivision.
9. Llama al método main(). El { marca el comienzo de este método.
10. Declarar una variable entera y asignarle el valor 11.
11. Declarar una variable entera b y asignarle el valor 0.
12. Declarar una variable doble c y asignarle el valor 0.
13. Utilice la instrucció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. Llama a la función zeroDivision y pasa a los 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. Final del cuerpo del bloque try/catch.
17. Atrapa la excepción. El mensaje de error devuelto se almacenará en el mensaje variable.
18. Imprima el mensaje de error devuelto en la consola.
19. Final del cuerpo del bloque catch.
20. El programa debe devolver un valor después de una ejecución exitosa.
21. Fin del cuerpo de la función main().

Excepciones estándar de C++

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

Excepción Descripción std::exceptionEsta es una excepción y la clase padre de todas las excepciones estándar de C++.std::bad_allocEsta excepción es lanzada por una nueva palabra clave.std::bad_castEsta es una excepción lanzada por dynamic_cast.std::bad_exceptionUn dispositivo útil para manejar excepciones inesperadas en programas C++.std::bad_typeidUna excepción lanzada por typeid.std::logic_errorEsta excepción es teóricamente detectable al leer el código.std::domain_errorEsta es una excepción lanzada después de usar un dominio matemáticamente no válido.std::invalid_argumentUna excepción lanzada por usar argumentos no válidos .std::length_errorUna excepción lanzada después de crear un gran std::string.std::out_of_rangeLanzado por at method.std::runtime_errorEsta es una excepción que no se puede detectar mediante la lectura del código.std::overflow_errorEsta excepción se lanza después de la ocurrencia de un desbordamiento matemático. std::range_error Esta excepción se lanza cuando intenta almacenar un valor fuera de rango. std::underflow_error desbordamiento atemático.

Excepciones definidas por el usuario

La clase std::exception de C++ nos permite definir objetos que pueden lanzarse como excepciones. Esta clase se ha definido en el encabezado . La clase nos proporciona una función de miembro virtual llamada qué.

Esta función devuelve una secuencia de caracteres terminada en cero 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 tal 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 la clase.
6. Sobrescriba la función de 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 usará para capturar nuestra nueva excepción, después de lo cual se llamará a newException.
11. Llama a la función main(). La lógica del programa debe agregarse dentro de su cuerpo. El { marca el comienzo de su cuerpo.
12. Use una declaración de prueba 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. Lanzar la excepción newex si se detecta.
14. Fin del cuerpo de prueba.
15. Utilice la instrucción catch para capturar 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 instrucció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 el manejo de excepciones en C++, puede manejar errores en 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, coloca una sección de código debajo del bloque try-catch.
• La palabra clave throw ayuda al programa a generar excepciones, lo que ayuda al programa a manejar el problema.
• La palabra clave try ayuda a identificar el bloque de código para el que se activarán determinadas excepciones.
• Podemos sobrescribir la función what() del archivo de encabezado de excepción para definir nuestras excepciones.