Constructor dinámico en C++ con ejemplos

Cuando la asignación de memoria se realiza dinámicamente usando un asignador de memoria dinámico nuevo en un constructor , se conoce como constructor dinámico . Al usar esto, podemos inicializar dinámicamente los objetos. 
Ejemplo 1: 
 

#include <iostream>
using namespace std;
 
class geeks {
    const char* p;
 
public:
    // default constructor
    geeks()
    {
 
        // allocating memory at run time
        p = new char[6];
        p = "geeks";
    }
 
    void display()
    {
        cout << p << endl;
    }
};
 
int main()
{
    geeks obj;
    obj.display();
}

Producción: 
 

geeks

Explicación : en esto, apuntamos a un miembro de datos de tipo char al que se le asigna memoria dinámicamente por el nuevo operador y cuando creamos una memoria dinámica dentro del constructor de la clase, esto se conoce como constructor dinámico.
Ejemplo 2: 
 

#include <iostream>
using namespace std;
 
class geeks {
    int* p;
 
public:
    // default constructor
    geeks()
    {
 
        // allocating memory at run time
        // and initializing
        p = new int[3]{ 1, 2, 3 };
 
        for (int i = 0; i < 3; i++) {
            cout << p[i] << " ";
        }
 
        cout << endl;
    }
};
 
int main()
{
 
    // five objects will be created
    // for each object
    // default constructor would be called
    // and memory will be allocated
    // to array dynamically
    geeks* ptr = new geeks[5];
}

1 2 3 
1 2 3 
1 2 3 
1 2 3 
1 2 3

dinámicamente
Explicación : en este programa, hemos creado una array de objetos dinámicamente. El primer objeto es ptr[0], el segundo es ptr[1] y así sucesivamente. Para cada creación de objeto, se llama al constructor predeterminado y para cada objeto, la memoria se asigna a la variable de tipo de puntero mediante un nuevo operador.
Ejemplo 3: 
 

#include <iostream>
using namespace std;
 
class geeks {
    int* p;
 
public:
    // default constructor
    geeks()
    {
 
        // allocating memory at run time
        p = new int;
        *p = 0;
    }
 
    // parameterized constructor
    geeks(int x)
    {
        p = new int;
        *p = x;
    }
    void display()
    {
        cout << *p << endl;
    }
};
 
int main()
{
 
    // default constructor would be called
    geeks obj1 = geeks();
    obj1.display();
 
    // parameterized constructor would be called
    geeks obj2 = geeks(7);
    obj2.display();
}

0
7

Explicación: en este tipo de entero, la variable de puntero se declara en la clase a la que se le asigna memoria dinámicamente cuando se llama al constructor. Cuando creamos el objeto obj1 , se llama al constructor predeterminado y la memoria se asigna dinámicamente a la variable de tipo puntero y se inicializa con el valor 0. Y de manera similar, cuando se crea obj2 , se llama al constructor parametrizado y la memoria se asigna dinámicamente.