A alocação de memória dinâmica em C ++ é um recurso muito importante que permite que você considere seus requisitos para lidar com a necessidade de recursos em tempo real. Neste artigo, estaríamos explorando Exploração em detalhes. As dicas a seguir serão abordadas neste artigo,
- Precisa de alocação de memória dinâmica?
- Alocação de memória usando Novo Palavra-chave
- Desalocação de memória usando excluir Palavra-chave
- Alocando matrizes dinamicamente
- Alocação de memória dinâmica para objetos
Então, vamos começar com este artigo sobre alocação de memória dinâmica em C ++
Precisa de alocação de memória dinâmica?
Digamos que queremos inserir uma frase como uma matriz de caracteres, mas não temos certeza sobre o número exato de caracteres necessários na matriz.
Agora, ao declarar o array de caracteres, se especificarmos seu tamanho menor que o tamanho da string desejada, obteremos um erro porque o espaço na memória alocado para o array é menor em comparação ao tamanho da string de entrada. Se especificarmos seu tamanho maior que o tamanho da string de entrada, o array receberá um espaço na memória que é muito maior do que o tamanho da string desejada, consumindo assim desnecessariamente mais memória, mesmo quando não for necessário.
No caso acima, não temos ideia sobre o tamanho exato do array até o tempo de compilação (quando o computador compila o código e a string é inserida pelo usuário). Nesses casos, usamos o Novo operador.
encontrar o maior número em um array java
C ++ define dois operadores unários Novo e excluir que realizam a tarefa de alocar e desalocar memória durante o tempo de execução. Como esses operadores (novo e excluir) operam na memória de armazenamento livre (memória Heap), eles também são chamados de operador de armazenamento livre. Os ponteiros fornecem o suporte necessário para o sistema de alocação de memória dinâmica em C ++.
Com a ajuda da Alocação Dinâmica, um programa pode obter memória durante o tempo de execução.
As variáveis globais e locais são alocadas na memória durante o tempo de compilação. No entanto, não podemos adicionar nenhuma variável global ou local durante o tempo de execução. Se o programa precisar usar uma quantidade variável de memória, precisaremos alocar memória durante o tempo de execução, como e quando necessário. E, claro, aqui as rotinas de alocação dinâmica podem servir ao propósito.
Diferenças entre a alocação de memória estática e a alocação de memória dinâmica:
Esta é uma arquitetura de memória básica usada para qualquer programa C ++:
Vamos precisar de uma imagem como esta
A pilha é usada para alocação de memória estática e Heap para alocação de memória dinâmica, ambos são armazenados na RAM do computador.
Variáveis que são alocadas na pilha enquanto a alocação de memória estática é armazenada diretamente na memória e o acesso a esta memória é muito rápido, também sua alocação é tratada quando o programa é compilado. Quando uma função ou método chama outra função que, por sua vez, chama outra função e assim por diante, a execução de todas essas funções permanece suspensa até que a última função retorne seu valor. A pilha é sempre armazenada em uma ordem LIFO (último a entrar, primeiro a sair), o bloco reservado mais recentemente é sempre o próximo bloco a ser liberado. Isso ajuda a manter o controle da pilha, liberar um bloco da pilha nada mais é do que ajustar um ponteiro.
Variáveis alocadas no heap têm sua memória alocada em tempo de execução enquanto alocação de memória dinâmica. O acesso a essa memória é um pouco mais lento em comparação com a pilha, mas o tamanho do heap é limitado apenas pelo tamanho da memória virtual. O elemento do heap não tem dependências entre si e pode sempre ser acessado aleatoriamente a qualquer momento. Podemos alocar um bloco a qualquer momento e liberá-lo a qualquer momento. Isso torna difícil controlar quais partes do heap são alocadas ou desalocadas a qualquer momento.
Continuando com este artigo sobre alocação de memória dinâmica em C ++
Alocação de memória usando Novo Palavra-chave
Em C ++ o Novo operador é usado para alocar memória em tempo de execução e a memória é alocada em bytes. o Novo operador denota uma solicitação de alocação de memória dinâmica no Heap. Se houver memória suficiente disponível, o Novo operador inicializa a memória e retorna o endereço da memória recém-alocada e inicializada para a variável de ponteiro.
Sintaxe:
datatype * pointer_name = novo datatype
Exemplo:
int * ptr = new int // Podemos declarar uma variável durante a alocação dinâmica das duas maneiras a seguir. int * ptr = new int (10) int * ptr = new int {15} // novo operador também é usado para alocar um bloco (uma matriz) de memória do tipo tipo de dados. int * ptr = new int [20] // A instrução acima aloca dinamicamente memória para 20 inteiros continuamente do tipo int e retorna um ponteiro para o primeiro elemento da sequência para o ponteiro ‘ptr’.Nota : Se o heap não tiver memória suficiente para alocar, a nova solicitação indica falha lançando uma exceção std :: bad_alloc, a menos que “nothrow” seja usado com o novo operador, caso em que retorna um ponteiro NULL. Portanto, é uma boa prática verificar a variável de ponteiro produzida por new antes de usá-la no programa.
Continuando com este artigo sobre alocação de memória dinâmica em C ++
Desalocação de memória usando excluir Palavra-chave:
Uma vez que a memória heap é alocada para uma variável ou objeto de classe usando o Novo palavra-chave, podemos desalocar esse espaço de memória usando a excluir palavra-chave.
Sintaxe:
delete pointer_variable // Aqui, pointer_variable é o ponteiro que aponta para o objeto de dados criado por new. delete [] pointer_variable // Para liberar a memória de matriz alocada dinamicamente apontada pela variável de ponteiro, usamos a seguinte forma de exclusão:
Exemplo:
delete ptr delete [] ptr
Nota : A extensão do objeto ou a vida útil do objeto é o tempo durante o qual o objeto permanece na memória durante a execução do programa. A alocação de memória de heap é mais lenta do que uma pilha, pois, na pilha, não há uma ordem específica na qual você possa alocar memória, enquanto na pilha ela segue LIFO.
Continuando com este artigo sobre alocação de memória dinâmica em C ++
Alocando matrizes dinamicamente
O principal uso do conceito de alocação de memória dinâmica é para alocar memória a um array quando temos que declará-lo especificando seu tamanho, mas não temos certeza sobre isso.
Vejamos, um exemplo para entender seu uso.
#include usando namespace std int main () {int len, sum = 0 cout<< 'Enter the no. of students in the class' <>len int * marks = new int [len] // Alocação de memória dinâmica cout<< 'Enter the marks of each student' << endl for( int i = 0 i>* (marcas + i)} para (int i = 0 i Explicação:
Neste exemplo, primeiro perguntamos ao usuário o número de alunos em uma classe e armazenamos seu valor na variável len. Em seguida, declaramos um array de inteiros e alocamos um espaço na memória dinamicamente igual ao valor armazenado na variável len usando esta instrução int * marcas = new int [comprimento], portanto, é alocado um espaço igual a 'comprimento * (tamanho 1 inteiro) '. O resto do código é autoexplicativo.
Continuando com este artigo sobre alocação de memória dinâmica em C ++
Alocação de memória dinâmica para objetos
Também podemos alocar objetos dinamicamente.
Como sabemos, o Construtor é uma função de membro de classe especial usada para inicializar um objeto e Destructor também é uma função de membro de classe que é chamada sempre que o objeto sai do escopo.
O destruidor pode ser usado para liberar a memória atribuída ao objeto. É chamado nas seguintes condições.
- Quando um objeto local sai do escopo
- Para um objeto global, quando um operador é aplicado a um ponteiro para o objeto da classe
Podemos novamente usar ponteiros enquanto alocamos memória dinamicamente para objetos.
Vejamos um exemplo de uma matriz de objetos.
#include usando namespace std class Random {public: Random () {cout<< 'Constructor' << endl } ~Random() { cout << 'Destructor' << endl } } int main() { Random* a = new Random[3] delete [] a // Delete array return 0 } Resultado:
Explicação:
O Construtor será chamado três vezes, pois estamos alocando memória para três objetos da classe Random. O Destructor também será chamado três vezes durante cada um desses objetos. ‘Random * a = new Random [3]’ esta afirmação é responsável pela alocação de memória dinâmica de nosso objeto.
relacionamento java tem um
Assim, chegamos ao fim deste artigo sobre ‘Dynamic Memory Allocation C ++’. Se você deseja saber mais, confira o pela Edureka, uma empresa de aprendizagem online confiável. O curso de certificação e treinamento Java J2EE e SOA da Edureka foi projetado para treiná-lo tanto para os conceitos básicos e avançados do Java, juntamente com várias estruturas Java como Hibernate e Spring.
Tem alguma questão para nós? Mencione isso na seção de comentários deste blog e entraremos em contato com você o mais breve possível.