Já na alocação dinâmica de memória, a memória é alocada enquanto a execução é iniciada. Essa memória é alocada manualmente pelo programador em tempo de execução, também conhecida como alocação de memória em tempo de execução em C++. O tamanho da memória dinâmica pode ser alterado em qualquer posição do programa, pois no momento da declaração não mencionamos um tamanho que possa ser fixo. Apenas fornecemos o valor diretamente para a variável.
Diferença de alocação de memória para variáveis normais
Em variáveis normais, a memória alocada por um compilador é alocada e desalocada automaticamente. Quando a memória é alocada dinamicamente pelo programador, ele deve remover ou desalocar a memória quando ela não for mais útil na execução posterior do código-fonte. Essa situação causa um 'vazamento de memória' quando o programa é encerrado enquanto a memória não é desalocada.
Operadores para alocação dinâmica
Em C++, dois operadores ajudam na alocação e desalocação de memória: ‘new’ e ‘delete’ que são usados para alocar e desalocar a memória de uma maneira melhor.
Novo operador
Significa a demanda por alocação de memória. O novo operador inicializa a memória e retorna o endereço dessa memória alocada para a variável de ponteiro se houver memória suficiente disponível.
objeto ponteiro = novo dados - modelo ;
Excluir operador
Assim como o operador new, um operador delete é usado para remover a memória alocada. Em C++, o programador pode usar este operador para desalocação.
# Excluir pointer_variable;
Exemplo 1
Neste exemplo, introduziremos dois ponteiros: um é um ponteiro do tipo inteiro e o outro é um ponteiro flutuante. Os ponteiros são inicializados usando um sinal de asterisco com eles.
# Int * pointInt;# Float *pointfloat;
Ao usar essas duas impressoras, alocaremos a memória dinamicamente.
Papel dos ponteiros na alocação dinâmica:
A memória do espaço de armazenamento é desenvolvida na forma de blocos. Sempre que executamos um programa ou realizamos qualquer operação, a memória é alocada para esse fim específico. Essa memória possui um endereço especial associado ao programa que identifica qual processo ou programa é permitido naquela memória. Qualquer slot de memória é acessado através do endereço ao qual pertence. Portanto, esse endereço é armazenado por meio dos ponteiros. Resumindo, precisamos de ponteiros para acessar a memória e da mesma forma, para alocar uma parte específica da memória para qualquer tarefa. Ponteiros são necessários para armazenar endereços.
Como a palavra-chave ‘new’ é usada para a alocação dinâmica de memória na alocação manual, a memória é alocada pelo compilador. Não precisamos alocar memória em tempo de execução. Mas como a alocação dinâmica é aleatória, precisamos identificar os ponteiros e para o processo de vinculação, esse novo operador é usado.
# Pointint = novo int;Da mesma forma, o ponteiro flutuante é vinculado da mesma forma. Após o processo de vinculação, atribuiremos qualquer valor à memória que desejamos reservar para qualquer operação. Ao declarar o ponteiro, atribuímos um valor específico à memória.
# *pointInt = 50;Um valor flutuante para os pontos flutuantes também é declarado. Exiba os valores após a atribuição.
Como discutimos, o operador 'novo' é usado para alocar enquanto 'excluir' é usado para desalocar memória. Portanto, depois de concluir a tarefa ou operação no código, removeremos a memória que alocamos para a tarefa.
É melhor desalocar essa parte da memória para que qualquer outro processo possa aproveitar isso. Aplicaremos essa alocação a ambos os ponteiros.
Excluir ponto flutuador ; 
Depois de salvar o código no editor de texto, o terminal do Ubuntu permite que você execute o código-fonte dentro do arquivo por meio de um compilador g++.
$ g++ -o mem mem.c$ ./mem
Após a execução, você verá os valores atribuídos à memória.
Exemplo 2
Este exemplo tem o envolvimento da interação do usuário. Pegaremos uma variável numérica que conterá um valor do usuário. Este programa armazenará o resultado no GPA dos alunos. Todos os resultados serão salvos em tempo de execução.
Quando o usuário insere o número de alunos, a memória é alocada para cada número. Aqui é inicializado um ponteiro do tipo float que será utilizado na alocação de memória dos resultados.
Pegamos o ponteiro em float já que GPA está em notação decimal. Tomamos uma matriz do tipo ponteiro para o GPA, pois pode resultar em vários alunos.
Essa matriz de ponteiro com a palavra-chave ‘new’ vinculará a execução à memória. O GPA será inserido para cada aluno. Como não estamos familiarizados com o número de alunos que o usuário deseja adicionar, usamos um loop for para inserir o GPA até o número inserido. A cada repetição do loop, o usuário é solicitado a informar o resultado identificando o aluno. Depois que o resultado for salvo, usaremos novamente um loop para exibir todos os GPAs dos alunos. No final, a matriz do tipo de ponteiro é excluída, pois o objetivo do armazenamento dinâmico foi cumprido.
Excluir [ ] ptr ;Agora vamos executar o código acima mencionado. O usuário será primeiro solicitado a inserir o número de alunos. Em seguida, o GPA de cada aluno será inserido.
Exemplo 3
Este exemplo usa os operadores new e delete para o objeto da classe. Esta classe contém uma variável privada do tipo inteiro que armazena a idade. Na parte pública de uma classe, é criado o construtor que inicializará a idade com um número '10'. Outra função é usada aqui que exibirá a idade inicializada no construtor.
Agora iremos para o programa principal para a alocação dinâmica. O objeto da classe é criado dinamicamente.
Aluna * ptr = novo aluna ( ) ; 
Quando o objeto é formado, o construtor será implementado automaticamente. Uma chamada de função será feita para obter a idade. Isso será feito através do ptr.
Ptr - > getAge ( ) ;E no final, a memória será liberada.
Conclusão
A alocação dinâmica de memória é alocada na execução do tempo de execução pelo programador, em vez do armazenamento fixo identificado pelo compilador. Essa alocação é aleatória e pode ser eliminada após sua utilização. Considerando que, na maioria dos casos, antes da remoção, o processo de execução é interrompido e essa alocação dinâmica causa vazamentos de memória. Implementamos esse fenômeno em diferentes abordagens no sistema Ubuntu Linux usando a linguagem de programação C++.