Alocação de memória dinâmica em C ++

A alocação de memória é determinada no momento da declaração variável. Mas na maioria dos casos, não sabemos quanta memória é necessária para uma variável específica. Nesse caso, a alocação de memória deve ser feita no tempo de execução. A alocação de memória de tempo de execução do programa é conhecida como alocação de memória dinâmica. Na alocação de memória dinâmica, não sabemos o tamanho real da variável. Alocamos manualmente a memória dessa variável e também pode ser uma matriz ou objeto de uma classe. Ponteiros desempenham um papel fundamental na alocação de memória dinâmica. Quando alocamos dinamicamente a memória, o “novo”A palavra -chave é usada para dizer ao compilador que estamos alocando dinamicamente a memória. Quando terminamos de alocar a memória, no final, precisamos manualmente “excluir”Que a memória dinâmica reservada. Em outras linguagens de programação como Python e Java, não precisamos alocar dinamicamente a memória porque o compilador faz isso automaticamente. Mas em C e C ++, fazemos isso manualmente usando o novo (para reservar espaço) e excluir (para o espaço livre) Palavras -chave.

Por que alocamos dinamicamente a memória?

Em C ++, a alocação de memória dinâmica é feita quando não sabemos o tamanho real da variável ou itens que queremos armazenar em uma variável. Os valores totais que precisam ser armazenados são decididos no tempo de execução. Heap aloca a memória dinâmica, mas no caso da estática, a memória é atribuída em uma pilha. Portanto, quando não sabemos o tamanho exato das variáveis ​​e isso deve ser feito no tempo de execução, aloque a memória dinamicamente.

Sintaxe:

Memória de reserva
Pointer_variable = new Data_type;

Primeiro, temos que reservar a memória em uma pilha. Para esse fim, definimos uma variável de tipo de ponteiro igual ao “novoPalavra -chave e defina o tipo de variável. O "novo”Palavra -chave reserva a memória na pilha.

Também podemos definir uma variável do tipo Array.

Pointer_variable = new Data_type [size];

Para inicializar a variável, apenas colocamos o valor nos parênteses após o data_type () como este:

Pointer_variable = new Data_type (valor);
Memoria livre
excluir pointer_variable;

Quando terminarmos a alocação de memória dinâmica, desalocine a memória para salvar os dados do vazamento de memória. O "excluirPalavra -chave com o nome da variável de ponteiro libera a memória dinâmica.

Alocação de memória dinâmica da variável

Vamos explicar o processo de alocação e desalocação da memória dinâmica de uma variável do tipo inteiro.

Código:

#incluir
usando namespace std;
int main ()
int* p_value = null;
p_value = new int;
*p_value = 674;
cout<< "Value of p_valueis : " << *p_value<excluir p_value;
retornar 0;

Inicie este código incluindo o arquivo de cabeçalho para acessar os métodos de entrada e saída da biblioteca. Esta biblioteca possui métodos internos que podemos acessar em nosso programa. Agora, chame o método main () e defina uma variável de ponteiro "*p_value" para segurar o endereço da pilha, pois a alocação de memória dinâmica é feita na pilha. A alocação estática é feita na pilha, porque já sabemos que a quantidade de dados significa o tamanho da variável. Inicialize o ponteiro inteiro com "nulo".

Em seguida, aloque o ponteiro "P_VALUE" a memória dinâmica da variável com a palavra -chave "nova" e o tipo de dados "int" da variável. Ao usar o termo "novo", o compilador é instruído a alocar memória de heap para a variável do tipo inteiro. Além disso, armazene um valor de "674" no tipo de ponteiro "*p_value" variável. Em seguida, execute o comando "cout" para imprimir a linha "Valor de P_Value" e o valor da variável "*p_value" que é armazenada dinamicamente na pilha. Para recuperar os dados que são salvos na pilha, usamos o ponteiro. O ponteiro armazena e acessa os dados na pilha; não acessa diretamente os dados. Em seguida, use o comando "excluir" para excluir a variável "P_VALUE" do tipo ponteiro, para que não perdemos nossos dados ou nenhuma outra pessoa possa acessar nossos dados.

Saída:

O valor de P_Value é: 674

Alocação de memória dinâmica de um objeto de classe

Vamos definir uma classe e alocar dinamicamente a memória aos seus objetos nesta ilustração.

Código:

#incluir
usando namespace std;
classe program_0
público:
Program_0 ()
cout<< "I am Constructor" <
~ Program_0 ()
cout<< "I am Destructor" <
;
int main ()
Program_0* MyArray = new Program_0 [3];
excluir [] MyArray;
retornar 0;

Neste código, integra a biblioteca para usar o método "cout". Em seguida, use o espaço de nome padrão. Defina uma classe "program_0" e defina esta classe como pública. Os métodos de classe pública podem ser acessados ​​fora da aula. As outras classes também podem acessar os métodos desta classe. Defina o construtor e o destruidor nesta classe. Inicializamos os membros de dados da classe no construtor. O destruidor destrói os objetos assim que o programa é executado. Libera a memória depois que a tarefa é feita. Ambos são definidos pelo nome da classe.

No construtor program_0 (), escrevemos uma linha de código para imprimir uma mensagem no terminal. Da mesma forma, no ~ program_0 () destruidor, exiba uma mensagem executando a instrução "cout". Sempre que o objeto de classe é criado, os construtores e destruidores são chamados. Quando chamamos a classe em particular, ele executa o construtor e depois executa outras operações que atribuímos a ele. Depois de terminar o processo, o destruidor é chamado e destrói todos os objetos criados para acessar os métodos de classe e os membros de dados.

Além disso, execute a função principal () deste código. Cada classe é chamada e seus objetos são criados dentro deste método. Crie um objeto "**MyArray" do tipo ponteiro da classe "Program_0" e aloque a memória dinâmica usando a palavra -chave "nova". Aqui, definimos o tamanho da matriz 3. A classe é chamada três vezes, e o construtor também é executado três vezes. Depois de tudo isso, o destruidor é chamado três vezes para liberar o espaço. O destruidor exclui o objeto que chama a classe três vezes.

Saída:

Eu sou construtor
Eu sou construtor
Eu sou construtor
Eu sou destruidor
Eu sou destruidor
Eu sou destruidor

Conclusão

Este documento analisa a alocação de memória dinâmica em C++. Também observamos por que alocamos dinamicamente a memória. A alocação de memória dinâmica é importante quando não sabemos o tamanho real dos dados a serem armazenados. Em outras línguas, como o Python, os programadores não precisam alocar manualmente a memória porque o compilador faz isso automaticamente. Depois de alocar a memória, armazenar os dados lá e fornecer acesso a ela, a memória é desalocada. Desalocação é importante porque, se não negociarmos a memória, há uma chance de vazamento de memória. A alocação de memória dinâmica de uma variável inteira e um objeto de classe é explicada nos códigos deste guia.