Manejo de excepciones y destrucción de objetos en C++

Una excepción se denomina un error no deseado que surge durante el tiempo de ejecución del programa. La práctica de separar el programa/código que causa la anomalía del resto del programa/código se conoce como manejo de excepciones . 

Un objeto se denomina como una instancia de la clase que tiene el mismo nombre que el de la clase. Un destructor es una función miembro de una clase que tiene el mismo nombre que la clase pero está precedida por un signo ‘~’ (tilde), también se llama automáticamente después de que se agota el alcance del código. La práctica de pulverizar o demoler la memoria del objeto existente se denomina destrucción de objetos . 
En otras palabras, la clase del programa nunca tiene ningún tipo de memoria o almacenamiento, es el objeto el que tiene la memoria o el almacenamiento y para desasignar/destruir la memoria del objeto creado usamos destructores.

Por ejemplo :

// C++ Program to show the sequence of calling
// Constructors and destructors
#include <iostream>
using namespace std;
 
// Initialization of class
class Test {
public:
    // Constructor of class
    Test()
    {
        cout << "Constructing an object of class Test "
             << endl;
    }
 
    // Destructor of class
    ~Test()
    {
        cout << "Destructing the object of class Test "
             << endl;
    }
};
 
int main()
{
    try {
        // Calling the constructor
        Test t1;
        throw 10;
       
    } // Destructor is being called here
      // Before the 'catch' statement
    catch (int i) {
        cout << "Caught " << i << endl;
    }
}

Producción: 

Constructing an object of class Test 
Destructing the object of class Test 
Caught 10

Cuando se lanza una excepción, los destructores de los objetos (cuyo ámbito termina con el bloque try) se llaman automáticamente antes de que se ejecute el bloque catch. Es por eso que el programa anterior imprime » Destruyendo un objeto de Prueba » antes de » Atrapado 10 «.

¿Qué sucede cuando se lanza una excepción desde un constructor?

Ejemplo:

// C++ Program to show what really happens
// when an exception is thrown from
// a constructor
#include <iostream>
using namespace std;
 
class Test1 {
public:
    // Constructor of the class
    Test1()
    {
        cout << "Constructing an Object of class Test1"
             << endl;
    }
    // Destructor of the class
    ~Test1()
    {
        cout << "Destructing an Object the class Test1"
             << endl;
    }
};
 
class Test2 {
public:
    // Following constructor throws
    // an integer exception
    Test2() // Constructor of the class
    {
        cout << "Constructing an Object of class Test2"
             << endl;
        throw 20;
    }
    // Destructor of the class
    ~Test2()
    {
        cout << "Destructing the Object of class Test2"
             << endl;
    }
};
 
int main()
{
    try {
        // Constructed and destructed
        Test1 t1;
 
        // Partially constructed
        Test2 t2;
 
        // t3 is not constructed as
        // this statement never gets executed
        Test1 t3; // t3 is not called as t2 is
                  // throwing/returning 'int' argument which
                  // is not accepeted
                  //  is the class test1'
    }
    catch (int i) {
        cout << "Caught " << i << endl;
    }
}

Salida :  

Constructing an Object of class Test1
Constructing an Object of class Test2
Destructing an Object the class Test1
Caught 20

Los destructores solo se llaman para los objetos completamente construidos. Cuando el constructor de un objeto lanza una excepción, no se llama al destructor de ese objeto.  

Prediga la salida del siguiente programa:

// C++ program to show how many times
// Constructors and destructors are called
#include <iostream>
using namespace std;
 
class Test {
    static int count; // Used static to initialise the scope
                      // Of 'count' till lifetime
    int id;
 
public:
  // Constructor
    Test()
    {
        count++;
        id = count;
        cout << "Constructing object number " << id << endl;
        if (id == 4)
            throw 4;
    }
  // Destructor
    ~Test()
    {
        cout << "Destructing object number " << id << endl;
    }
};
 
int Test::count = 0;
 
// Source code
int main()
{
    try {
        Test array[5];
    }
    catch (int i) {
        cout << "Caught " << i << endl;
    }
}

Salida :

Constructing object number 1
Constructing object number 2
Constructing object number 3
Constructing object number 4
Destructing object number 3
Destructing object number 2
Destructing object number 1
Caught 4