Memória Dinâmica C++

Uma boa compreensão de como a memória dinâmica realmente funciona em C++ é essencial para se tornar um bom programador de C++. A memória em seu programa C++ é dividida em duas partes -

• 
  A pilha − Todas as variáveis ​​declaradas dentro da função ocuparão memória da pilha.
  
• 
  A pilha − Esta é a memória não utilizada do programa e pode ser usada para alocar a memória dinamicamente quando o programa é executado.
  

Muitas vezes, você não sabe antecipadamente quanta memória precisará para armazenar informações específicas em uma variável definida e o tamanho da memória necessária pode ser determinado em tempo de execução.

Você pode alocar memória em tempo de execução dentro do heap para a variável de um determinado tipo usando um operador especial em C++ que retorna o endereço do espaço alocado. Este operador é chamado de novo operador.

Se você não precisar mais de memória alocada dinamicamente, você pode usar delete operador, que desaloca memória que foi anteriormente alocada pelo novo operador.

novos e excluir operadores

Existe a seguinte sintaxe genérica para usar novo operador para alocar memória dinamicamente para qualquer tipo de dados.

new data-type;

Aqui, tipo de dados pode ser qualquer tipo de dados interno, incluindo uma matriz ou qualquer tipo de dados definido pelo usuário, incluindo classe ou estrutura. Vamos começar com os tipos de dados internos. Por exemplo, podemos definir um ponteiro para digitar double e então solicitar que a memória seja alocada em tempo de execução. Podemos fazer isso usando o novo operador com as seguintes declarações -

double* pvalue  = NULL; // Pointer initialized with null
pvalue  = new double;   // Request memory for the variable

A memória pode não ter sido alocada com sucesso, se o armazenamento livre estiver esgotado. Portanto, é uma boa prática verificar se o novo operador está retornando o ponteiro NULL e tomar as medidas apropriadas conforme abaixo -

double* pvalue  = NULL;
if( !(pvalue  = new double )) {
   cout << "Error: out of memory." <<endl;
   exit(1);
}

O malloc() função de C, ainda existe em C++, mas é recomendável evitar o uso da função malloc(). A principal vantagem de new sobre malloc() é que new não apenas aloca memória, mas constrói objetos que é o propósito principal de C++.

A qualquer momento, quando você sentir que uma variável que foi alocada dinamicamente não é mais necessária, você pode liberar a memória que ela ocupa no armazenamento livre com o operador 'delete' da seguinte maneira -

delete pvalue;        // Release memory pointed to by pvalue

Vamos colocar os conceitos acima e formar o exemplo a seguir para mostrar como 'novo' e 'excluir' funcionam −
Demonstração ao vivo

#include <iostream>
using namespace std;

int main () {
   double* pvalue  = NULL; // Pointer initialized with null
   pvalue  = new double;   // Request memory for the variable
 
   *pvalue = 29494.99;     // Store value at allocated address
   cout << "Value of pvalue : " << *pvalue << endl;

   delete pvalue;         // free up the memory.

   return 0;
}

Se compilarmos e executarmos o código acima, isso produziria o seguinte resultado -

Value of pvalue : 29495

Alocação de memória dinâmica para arrays

Considere que você deseja alocar memória para uma matriz de caracteres, ou seja, uma string de 20 caracteres. Usando a mesma sintaxe que usamos acima, podemos alocar memória dinamicamente conforme mostrado abaixo.

char* pvalue  = NULL;         // Pointer initialized with null
pvalue  = new char[20];       // Request memory for the variable

Para remover o array que acabamos de criar, a instrução ficaria assim −

delete [] pvalue;             // Delete array pointed to by pvalue

Seguindo a sintaxe genérica semelhante do novo operador, você pode alocar para uma matriz multidimensional da seguinte maneira -

double** pvalue  = NULL;      // Pointer initialized with null 
pvalue  = new double [3][4];  // Allocate memory for a 3x4 array 

No entanto, a sintaxe para liberar a memória para array multidimensional ainda permanecerá a mesma acima -

delete [] pvalue;            // Delete array pointed to by pvalue

Alocação de memória dinâmica para objetos

Objetos não são diferentes de tipos de dados simples. Por exemplo, considere o código a seguir onde usaremos uma matriz de objetos para esclarecer o conceito -
Demonstração ao vivo

#include <iostream>
using namespace std;

class Box {
   public:
      Box() { 
         cout << "Constructor called!" <<endl; 
      }
      ~Box() { 
         cout << "Destructor called!" <<endl; 
      }
};
int main() {
   Box* myBoxArray = new Box[4];
   delete [] myBoxArray; // Delete array

   return 0;
}

Se você alocasse uma matriz de quatro objetos Box, o construtor Simple seria chamado quatro vezes e, da mesma forma, ao excluir esses objetos, o destruidor também será chamado o mesmo número de vezes.

Se compilarmos e executarmos o código acima, isso produziria o seguinte resultado -

Constructor called!
Constructor called!
Constructor called!
Constructor called!
Destructor called!
Destructor called!
Destructor called!
Destructor called!