Ciclo de vida de Objetos en C++ con Ejemplo

En la programación orientada a objetos , los objetos son las instancias de una clase que tiene su propio estado (variables) y comportamiento (métodos) .
 

Cada clase tiene dos métodos especiales relacionados con la creación y destrucción de objetos de una clase : constructores y destructores .
 

Ciclo de vida del objeto C++:

Hay varios pasos que deben seguirse para completar el ciclo de vida de un objeto: 
 

1. En primer lugar, se necesita alguna clase para definir un objeto basado en clases. Por lo tanto, se crea una clase de ejemplo en el diagrama anterior.
2. Un constructor construye valores del tipo de clase. Es una función miembro cuyo nombre es el mismo que el nombre de la clase. Este proceso implica la inicialización de miembros de datos y, con frecuencia, la asignación de almacenamiento gratuito utilizando new.
3. Se puede inicializar el objeto de ejemplo como se creó anteriormente. La inicialización requiere que se llame a una nueva palabra clave para asignar algo de memoria a este objeto.
4. Se puede usar algo de lógica en el constructor, que se ejecutará durante la inicialización.
5. Una vez finalizada la ejecución, se llama al destructor. Un destructor es una función miembro cuyo propósito es destruir valores del tipo de clase. Es una función miembro cuyo nombre está precedido por el carácter de tilde (~) .
6. Durante todo este ciclo de vida, recuerda los siguientes hechos: 
   • Los constructores pueden estar sobrecargados .
   • Se invoca un constructor cuando su tipo asociado se usa en una definición.
   • Los destructores se invocan implícitamente cuando un objeto queda fuera del alcance.
   • Los constructores y destructores no tienen tipos de devolución y no pueden usar declaraciones de devolución .

A continuación se muestra el programa sobre cómo funcionan los constructores y destructores en C++ :
 

// C++ program to demonstrate the
// object allocation & deallocation
 
#include <iostream>
using namespace std;
 
class object {
public:
    // Constructor
    object()
    {
        // Constructor has same name
        // as that of class name
        cout << "The object is created"
             << "\n";
    }
 
    // Destructor
    ~object()
    {
        // Destructor has same name as
        // class and is preceded by ~ sign
        cout << "The object is destructed"
             << "\n";
    }
};
 
// Driver Code
int main()
{
    // Object creation
    object obj1;
 
    return 0;
}

The object is created
The object is destructed

Cuando varios objetos están involucrados:

Cuando se crean varios objetos a partir de la misma clase, la construcción de los objetos se lleva a cabo de la misma forma en que se crean. Sin embargo, la destrucción sigue el enfoque LIFO (último en entrar, primero en salir) , es decir, el objeto que se creó primero se destruirá en último lugar. Ya que, al trabajar con una sola clase, cada nuevo objeto es independiente del anterior por lo que el orden de destrucción no importa mucho. Sin embargo, al trabajar con herencia , este orden LIFO tiene sentido.

A continuación se muestra el programa para ilustrar lo mismo:
 

// C++ program to illustrate the
// constructor and destructor when
// multiple objects are created
 
#include <iostream>
using namespace std;
 
// obj Class
class obj {
public:
    // Declare class variable to
    // keep count on objects
    static int obj_count;
 
    // Constructor
    obj()
    {
        obj_count++;
        cout << "The obj - "
             << obj_count
             << " - is created"
             << "\n";
    }
 
    // Destructor
    ~obj()
    {
        cout << "The obj - "
             << obj_count
             << " - is destructed"
             << "\n";
        obj_count--;
    }
};
 
// Static members are always defined
// outside of the class
int obj::obj_count = 0;
 
// Driver Code
int main()
{
    // Creating objects
    obj obj1{};
    obj obj2{};
 
    return 0;
}

The obj - 1 - is created
The obj - 2 - is created
The obj - 2 - is destructed
The obj - 1 - is destructed

Comportamiento de construcción y destrucción de objetos en caso de herencia:

La herencia en C++ sigue un enfoque IS-A . Cuando una clase B hereda una clase A , decimos B ES-A . Decimos clase B como clase derivada y clase A como clase base. Junto con el estado y los comportamientos, la clase B también hereda el constructor y el destructor de la clase A. Hay algunas reglas que guían la herencia del constructor y el destructor.

• La clase derivada no puede anular ni sobrecargar el constructor y el destructor de la clase base.
• Primero tiene lugar la construcción de la clase base, seguida de la construcción de la clase derivada.
• La destrucción de la clase derivada tiene lugar primero.

A continuación se muestra el programa para ilustrar lo mismo:
 

// C++ program to demonstrates the
// object Allocation and deallocation
// during inheritance B stands for base
// class and D stands for derived class
 
#include <iostream>
using namespace std;
 
// Class B
class B {
public:
    // Constructor
    B(int b = 0)
        : _b(b)
    {
        cout << "constructor of base class "
             << "created with value - "
             << _b << '\n';
    }
 
    // Destructor
    ~B()
    {
        cout << "Destructor of base class "
             << "called \n";
    }
    int _b;
};
 
// Inherit class D from class B
class D : public B {
 
public:
    D(int d)
        : _d(d)
    {
        // Default constructor of b
        // Is called automatically
        cout << "constructor of derived "
             << " class created with value - "
             << _d << '\n';
    }
 
    // Overloaded Constructor
    D(int b, int d)
        : B(b), _d(d)
    {
        cout << "constructor of derived class "
             << "created with value - "
             << _d << '\n';
    }
 
    // Destructor
    ~D()
    {
        cout << "Destructor of derived class "
             << "called \n";
    }
 
private:
    int _d;
};
 
// Driver Code
int main()
{
    // Object of class B
    B b(34);
 
    // Objects of class D
    D d2(89);
    D d1(56, 78);
 
    return 0;
}

¿Por qué se utiliza el enfoque LIFO durante la destrucción de objetos?

Dado que la clase secundaria hereda estados y comportamientos de la clase principal, tiene sentido que primero se termine todo el trabajo de la clase secundaria y luego solo se destruya el objeto de la clase base . Supongamos que la clase secundaria accede a un estado de la clase principal pero el objeto principal ha sido destruido, en este caso, se produciría un error y, por lo tanto , se sigue el orden LIFO en la destrucción. Esto funciona bien incluso cuando se trabaja con múltiples objetos de una sola clase.