Constructores predeterminados en C++

Se dice que un constructor sin argumentos o con el valor predeterminado para cada argumento es el constructor predeterminado . 

¿Cuál es el significado del constructor predeterminado? 

Se utilizan para crear objetos, que no tienen ningún valor inicial específico. 

¿Se proporciona automáticamente un constructor predeterminado?

Si no se declaran explícitamente constructores en la clase, se proporciona automáticamente un constructor predeterminado. 

¿Puede un constructor predeterminado contener un argumento predeterminado?

Sí, un constructor puede contener un argumento predeterminado con valores predeterminados.

¿Habrá algún código insertado por el compilador en el constructor predeterminado implementado por el usuario detrás de escena?

El compilador declarará implícitamente el constructor predeterminado si el programador no lo proporciona, lo definirá cuando sea necesario. Se requiere el constructor predeterminado definido por el compilador para realizar cierta inicialización de los componentes internos de la clase. No tocará los miembros de datos o los tipos de datos antiguos simples (agregados como una array, estructuras, etc.). Sin embargo, el compilador genera código para el constructor predeterminado según la situación.

Considere una clase derivada de otra clase con el constructor predeterminado, o una clase que contenga otro objeto de clase con el constructor predeterminado. El compilador necesita insertar código para llamar a los constructores predeterminados de la clase base/objeto incrustado.

// CPP program to demonstrate Default constructors
#include <iostream>
using namespace std;
 
class Base {
public:
    // compiler "declares" constructor
};
 
class A {
public:
    // User defined constructor
    A() { cout << "A Constructor" << endl; }
 
    // uninitialized
    int size;
};
 
class B : public A {
    // compiler defines default constructor of B, and
    // inserts stub to call A constructor
 
    // compiler won't initialize any data of A
};
 
class C : public A {
public:
    C()
    {
        // User defined default constructor of C
        // Compiler inserts stub to call A's constructor
        cout << "C Constructor" << endl;
 
        // compiler won't initialize any data of A
    }
};
 
class D {
public:
    D()
    {
        // User defined default constructor of D
        // a - constructor to be called, compiler inserts
        // stub to call A constructor
        cout << "D Constructor" << endl;
 
        // compiler won't initialize any data of 'a'
    }
 
private:
    A a;
};
 
// Driver Code
int main()
{
    Base base;
 
    B b;
    C c;
    D d;
 
    return 0;
}

A Constructor
A Constructor
C Constructor
A Constructor
D Constructor

Hay diferentes escenarios en los que el compilador necesita insertar código para garantizar la inicialización necesaria según los requisitos del idioma. Los tendremos en próximas publicaciones. Nuestro objetivo es estar al tanto de las partes internas de C++, no usarlas incorrectamente.

// CPP code to demonstrate constructor can have default
// arguments
#include <iostream>
using namespace std;
class A {
public:
    int sum = 0;
    A(); // default constructor with no argument
    A(int a, int x = 0) // default constructor with one
                        // default argument
    {
        sum = a + x;
    }
    void print() { cout << "Sum =" << sum << endl; }
};
int main()
{
    // This construct has two arguments. Second argument is
    // initialized with a value of 0 Now we can call the
    // constructor in two possible ways.
    A obj1(10, 20);
    A obj2(5);
    obj1.print();
    obj2.print();
    return 0;
}

Sum =30
Sum =5

Explicación: aquí tenemos un constructor con dos parámetros: un parámetro simple y un parámetro predeterminado. Ahora, hay dos formas de llamar a este constructor: 

1. Primero, podemos asignar valores a ambos argumentos y estos valores se pasarán al constructor y el argumento predeterminado x con valor 0 será anulado por el valor pasado durante la llamada (en este caso, 20). Por lo tanto, el código dará una salida de 30 (como sum= a+x, es decir, 10+20= 30).
2. La segunda forma es no pasar ningún valor para el parámetro predeterminado. Si lo hace, x tomará su valor predeterminado 0 como valor final y calculará una suma de 5 (como suma = a+x, es decir, 5+0=5). Escriba comentarios si encuentra algo incorrecto o si
    
   desea compartir más información sobre el tema tratado anteriormente.