Encabezado de excepción en C++ con ejemplos

C++ proporciona una lista de excepciones estándar definidas en el encabezado <excepción> en el espacio de nombres estándar, donde «excepción» es la clase base para todas las excepciones estándar. Todas las excepciones como bad_alloc , bad_cast , runtime_error , etc. generadas por la biblioteca estándar heredan de std::exception . Por lo tanto, todas las excepciones estándar se pueden capturar por referencia.

Archivo de cabecera:

#include <exception>

A continuación se muestran los errores que se arrojan en C++ :

A continuación se muestra el programa para ilustrar algunos de los errores en la clase de excepción en C++:

Programa 1:
a continuación se muestra la ilustración del error std::bad_alloc :

// C++ program to illustrate bad_alloc
// using class bad_alloc
#include <exception>
#include <iostream>
using namespace std;
  
// Function to illustrate bad_alloc
void createArray(int N)
{
    // Try Block
    try {
        // Create an array of length N
        int* array = new int[N];
  
        // If created successfully then
        // print the message
        cout << "Array created successfully"
             << " of length " << N << " \n";
    }
  
    // Check if the memory
    // was allocated or not
    // using class bad_alloc
    catch (bad_alloc& e) {
  
        // If not, print the error message
        cout << e.what()
             << " for array of length "
             << N << " \n";
    }
}
  
// Driver Code
int main()
{
    // Function call to create an
    // array of 1000 size
    createArray(1000);
  
    // Function call to create an
    // array of 1000000000 size
    createArray(1000000000);
    return 0;
}

// C++ program to illustrate bad_alloc
// using class exception
#include <exception>
#include <iostream>
using namespace std;
  
// Function to illustrate bad_alloc
void createArray(int N)
{
    // Try Block
    try {
        // Create an array of length N
        int* array = new int[N];
  
        // If created successfully then
        // print the message
        cout << "Array created successfully"
             << " of length " << N << " \n";
    }
  
    // Check if the memory
    // was allocated or not
    // using class exception
    catch (exception& e) {
  
        // If not, print the error message
        cout << e.what()
             << " for array of length "
             << N << " \n";
    }
}
  
// Driver Code
int main()
{
    // Function call to create an
    // array of 1000 size
    createArray(1000);
  
    // Function call to create an
    // array of 1000000000 size
    createArray(1000000000);
    return 0;
}

Array created successfully of length 1000 
std::bad_alloc for array of length 1000000000

Explicación:

• Para crear una array de longitud 1000 , la asignación de memoria fue exitosa y no hubo ninguna excepción .
• Para crear una array de longitud 1000, la asignación de memoria no tuvo éxito y se lanzó la excepción «std::bad_alloc» . La excepción lanzada es del tipo bad_alloc que se deriva de la excepción de clase. La función what() es una función virtual definida en la excepción de la clase base . La función what() devuelve una string terminada en nulo que generalmente es una descripción de error.

Nota: el operador «nuevo» lanza la excepción bad_alloc cuando falla la asignación de memoria .

¿Por qué capturamos una excepción por referencia?
La captura de una excepción por valor llamará al constructor de copias y creará una copia de la excepción que agrega una sobrecarga de tiempo de ejecución. Por lo tanto, capturar por referencia es una mejor opción. Si queremos modificar la excepción o agregar información adicional al mensaje de error, lo mejor es capturar por referencia. Para este caso:

catch (std::string str)
{
    s += "Additional info";
    throw;
}

El programa anterior quiere capturar la excepción, agregarle información y volver a lanzarla. Pero str es una variable de llamada por valor que se cambia localmente en la función y cuando la función vuelve a lanzar la excepción, se pasa la excepción original.

Código correcto:

catch (std::string& s)
{
    s += "Additional info";
    throw;
}

Programa 2:
A continuación se muestra el programa para ilustrar el logic_error :

// C++ program to illustrate logic_error
#include <exception>
#include <iostream>
using namespace std;
  
// Function to find factorial of N and
// throws error if occurs
void findFactorial(int N)
{
    // Initialise variable by 1
    int factorial = 1;
  
    // Check for errors
    try {
        // If N is less than zero then,
        // it shows errors as factorial
        // of negative number can't be
        // calculated
        if (N < 0) {
  
            // Exception object which
            // returns the message passed
            // to it
            throw invalid_argument(
                "negative not allowed");
        }
  
        // Find factorial if no error occurs
        for (int i = N; i > 0; i--) {
            factorial *= i;
        }
        cout << "Factorial of " << N
             << " is " << factorial << endl;
    }
  
    // Print the error message
    catch (exception& e) {
        cout << e.what();
    }
}
  
// Driver Code
int main()
{
    // Function call to find factorial
    // of 0
    findFactorial(0);
  
    // Function call to find factorial
    // of 3
    findFactorial(3);
  
    // Function call to find factorial
    // of -1
    findFactorial(-1);
  
    return 0;
}

Factorial of 0 is 1
Factorial of 3 is 6
negative not allowed