Orden de Llamada de Constructor/ Destructor en C++

Prerrequisito: Constructores 
Cada vez que creamos un objeto de una clase, el constructor predeterminado de esa clase se invoca automáticamente para inicializar los miembros de la clase. 

Si heredamos una clase de otra clase y creamos un objeto de la clase derivada, está claro que se invocará el constructor por defecto de la clase derivada pero antes se invocará el constructor por defecto de todas las clases base, es decir, el orden de invocación es que primero se invocará el constructor predeterminado de la clase base y luego se invocará el constructor predeterminado de la clase derivada.

¿Por qué se llama al constructor de la clase base al crear un objeto de clase derivada?

Para comprender esto, tendrá que recordar sus conocimientos sobre la herencia. ¿Qué sucede cuando una clase se hereda de otra? Los miembros de datos y las funciones de miembros de la clase base vienen automáticamente en la clase derivada según el especificador de acceso, pero la definición de estos miembros existe solo en la clase base. Entonces, cuando creamos un objeto de clase derivada, todos los miembros de la clase derivada deben inicializarse, pero los miembros heredados en la clase derivada solo pueden ser inicializados por el constructor de la clase base, ya que la definición de estos miembros existe solo en la clase base. Esta es la razón por la que primero se llama al constructor de la clase base para inicializar todos los miembros heredados. 

// C++ program to show the order of constructor call
// in single inheritance
  
#include <iostream>
using namespace std;
 
// base class
class Parent
{
    public:
     
    // base class constructor
    Parent()
    {
        cout << "Inside base class" << endl;
    }
};
 
// sub class
class Child : public Parent
{
    public:
     
    //sub class constructor
    Child()
    {
        cout << "Inside sub class" << endl;
    }
};
 
// main function
int main() {
      
    // creating object of sub class
    Child obj;
     
    return 0;
}

Producción:  

Inside base class
Inside sub class

Orden de llamada de constructor para Herencia Múltiple

Para el orden de herencia múltiple de la llamada al constructor, los constructores de la clase base se llaman en el orden de herencia y luego el constructor de la clase derivada. 

// C++ program to show the order of constructor calls
// in Multiple Inheritance
 
#include <iostream>
using namespace std;
 
// first base class
class Parent1
{  
    
    public:
     
    // first base class's Constructor   
    Parent1()
    {
        cout << "Inside first base class" << endl;
    }
};
 
// second base class
class Parent2
{
    public:
     
    // second base class's Constructor
    Parent2()
    {
        cout << "Inside second base class" << endl;
    }
};
 
// child class inherits Parent1 and Parent2
class Child : public Parent1, public Parent2
{
    public:
     
    // child class's Constructor
    Child()
    {
        cout << "Inside child class" << endl;
    }
};
 
// main function
int main() {
     
    // creating object of class Child
    Child obj1;
    return 0;
}

Producción:  

Inside first base class
Inside second base class
Inside child class

Llamada de orden de constructor y destructor para una determinada orden de herencia

 ¿Cómo llamar al constructor parametrizado de la clase base en el constructor de clases derivadas?

Para llamar al constructor parametrizado de la clase base cuando se llama al constructor parametrizado de la clase derivada, debe especificar explícitamente el constructor parametrizado de la clase base en la clase derivada como se muestra en el siguiente programa:

// C++ program to show how to call parameterized Constructor
// of base class when derived class's Constructor is called
 
#include <iostream>
using namespace std;
 
// base class
class Parent {
    int x;
 
public:
    // base class's parameterized constructor
    Parent(int i)
    {
        x = i;
        cout << "Inside base class's parameterized "
                "constructor"
             << endl;
    }
};
 
// sub class
class Child : public Parent {
public:
    // sub class's parameterized constructor
    Child(int x): Parent(x)
    {
        cout << "Inside sub class's parameterized "
                "constructor"
             << endl;
    }
};
 
// main function
int main()
{
 
    // creating object of class Child
    Child obj1(10);
    return 0;
}

Producción: 

Inside base class's parameterized constructor
Inside sub class's parameterized constructor

Puntos importantes : 

• Cada vez que se llama al constructor predeterminado de la clase derivada, se llama automáticamente al constructor predeterminado de la clase base.
• Para llamar al constructor parametrizado de la clase base dentro del constructor parametrizado de la subclase, debemos mencionarlo explícitamente.
• El constructor parametrizado de la clase base no se puede llamar en el constructor predeterminado de la subclase, debe llamarse en el constructor parametrizado de la subclase.

Los destructores en C++ se llaman en el orden opuesto al de los constructores.
Este artículo es una contribución de Abhirav Kariya y Harsh Agarwal . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.