Quando a alocação de memória é feita dinamicamente usando um alocador de memória dinâmico novo em um construtor , ele é conhecido como construtor dinâmico . Usando isso, podemos inicializar os objetos dinamicamente.

Exemplo 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 = new geeks();
    obj.display();
}

Saída:

geeks

Explicação : Nisto apontamos o membro de dados do tipo char que é alocado dinamicamente na memória por um novo operador e quando criamos memória dinâmica dentro do construtor da classe, isso é conhecido como construtor dinâmico.

Exemplo 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

dinamicamente.

Explicação : Neste programa, criamos um array de objetos dinamicamente. O primeiro objeto é ptr [0], o segundo é ptr [1] e assim por diante. Para cada criação de objeto, o construtor padrão é chamado e, para cada objeto, a memória é alocada para uma variável de tipo de ponteiro pelo novo operador.

Exemplo 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

Explicação: Neste tipo de número inteiro, a variável de ponteiro é declarada na classe que é atribuída à memória dinamicamente quando o construtor é chamado. Quando criamos o objeto obj1 , o construtor padrão é chamado e a memória é atribuída dinamicamente à variável de tipo de ponteiro e inicializada com o valor 0. E da mesma forma, quando obj2 é criado, o construtor parametrizado é chamado e a memória é atribuída dinamicamente.