Programa C++ para manejar los métodos de excepción

El manejo de excepciones es una forma de manejar el error de tiempo de ejecución, llevamos a cabo el manejo de excepciones, por lo que el flujo normal del programa se puede mantener incluso después de errores de tiempo de ejecución. Las excepciones son anomalías de tiempo de ejecución o condiciones anormales que encuentra un programa durante su ejecución. 

El mecanismo de manejo de excepciones ofrece una forma de transferir el control de una parte de un programa a otra. Esto hace que sea sencillo separar el código de manejo de errores del código escrito para abordar la funcionalidad real del programa.

C++ proporciona las siguientes palabras clave especializadas para el manejo de excepciones:

1. try: un bloque de código que puede generar una excepción generalmente se coloca dentro del bloque try, seguido de uno o más bloques de captura. Si ocurre una excepción, se lanza desde el bloque de prueba.
2. catch: este bloque detecta la excepción lanzada desde el bloque try, el código para abordar la excepción está escrito dentro de este bloque catch.
3. throw: la palabra clave throw se usa para lanzar una excepción. También se usa para enumerar las excepciones que lanza una función pero que no se maneja sola.

Sintaxis:

try 
{
    // Bloque de código para probar
  
   // Lanza una excepción cuando surge un problema throwException
   ;
}
catch() 
{
    // Bloque de código para manejar errores
}

A continuación se muestran los programas de C++ para mostrar cómo se manejan las excepciones en C++:

Ejemplo 1: a continuación se muestra el programa C++ para mostrar lo que sucede cuando se realiza la división por cero y no se manejan las excepciones.

// C++ program to show what happens 
// when division by zero is done 
// and exceptions are not handled
#include <iostream>
using namespace std;
  
// Driver code
int main() 
{
  int numerator = 5;
  int denominator = 0;
    
  int ans = numerator/denominator;
    
  // The result will not be displayed 
  cout << ans << endl;
    
  return 0;
    
}

Producción:

Excepción de coma flotante (SIGFPE)

El programa anterior mostrará un comportamiento anormal y la salida no se mostrará. Se lanza una excepción en el código, pero no se captura, por lo que mostrará una excepción de punto flotante o no mostrará ningún resultado.

A continuación se muestra el programa C++ para manejar la excepción de división por cero:

// C++ program to handle 
// divide by zero exception
#include <iostream>
using namespace std;
  
// Driver code
int main() 
{
  int numerator = 5;
  int denominator = 0;
  int result;
    
  try
  {
    if(denominator == 0)
    {
      throw denominator;
    }
    result = numerator / denominator;
  }
  catch(int ex)
  {
    cout << "Exception: Divide by zero not allowed :" << 
             ex << endl;
  }
  cout << "Division Result is: " << result;
    
  return 0;
}

Exception: Divide by zero not allowed :0
Division Result is: 4197440

Ejemplo 2: a continuación se muestra el programa C++ para ingresar un número entero de edad si la edad es menor de 18 y luego devolver NO, pero si la edad es mayor o igual a 18 entonces devolver Sí:

// C++ program to input an age integer 
// if the age is less than 18 then 
// return NO, but if the age is greater
// than or equal to 18 then return Yes
#include <iostream>
using namespace std;
  
// Driver code
int main() 
{
  try 
  {
    int age = 10;
    if (age >= 18) 
    {
      cout << "YES, you are old enough.";
    } 
    else 
    {
      throw (age);
    }
  }
  catch (int num) 
  {
    cout << "No, You must be at least 18 years old" <<
             endl;
    cout << "Age is: " << num;  
  }
  return 0;
}

No, You must be at least 18 years old
Age is: 10

Excepciones estándar de C++

C++ define un conjunto de excepciones estándar definidas en <exception> que se pueden usar en los programas. Estas excepciones se organizan en la jerarquía de clases padre-hijo. A continuación se muestra la tabla que enumera las excepciones estándar con una descripción:

Nueva excepción en C++

Las excepciones personalizadas se pueden definir heredando y anulando la funcionalidad de la clase de excepción.

Sintaxis:

 usar std::excepción

A continuación se muestra el programa C++ para definir una nueva excepción:

// C++ program to define a 
// new exception
#include <iostream>
#include <exception>
using namespace std;
  
struct Exceptions : public exception 
{
   const char* Except() const throw () 
   {
      return "GeeksforGeeks";
   }
};
   
// Driver code
int main() 
{
  try 
  {
    throw Exceptions();
  } 
  catch(Exceptions& it) 
  {
    cout << "Customised Exception caught" << 
             endl;
    cout << it.Except() <<endl;
  } 
  catch(std::exception& it) 
  {}
}

Customised Exception caught
GeeksforGeeks