C ++ novo operador

Em C ++, o termo “implantação dinâmica de memória” refere -se à distribuição manual de armazenamento por um programador. Heap é onde a memória compartilhada distribuída é implantada, enquanto a pilha é onde variáveis ​​não estáticas e locais adquirem recursos de memória.

Formulários

• A alocação de armazenamento de tamanho dinâmico, que não é possível com o armazenamento alocado pelo compilador, além de matrizes variadas, é um uso da alocação de memória dinâmica.
• O principal benefício é a versatilidade que ele dá aos programadores. Temos autonomia absoluta para alocar e liberar memória conforme necessário e não é mais necessário. Esta versatilidade é útil em muitas situações.

Como o C ++ aloca e desalocula memória?

Os métodos MaiC () e Calloc () em C ++ são usados ​​para alterar dinamicamente a memória na execução. Enquanto o método FREE () é usado para liberar a memória que foi alocada. Esses métodos são fornecidos por C ++ juntamente com os dois operadores 'novos' e 'excluir' que tornam a alocação e liberação de memória mais fáceis e eficientes.

A correlação entre a palavra -chave 'nova' e a nova operadora '

Essas duas coisas são diferentes uma da outra.

Dois eventos acontecem: distribuição de memória e formação de objetos. Ambos são tratados pela 'nova' palavra -chave. Chamando o operador e chamando o próprio construtor são os procedimentos para alocar armazenamento. O operador 'novo' não assumirá nenhuma responsabilidade por invocar o construtor, mas permite ajustar a estratégia de alocação de armazenamento. A nova palavra -chave tem essa responsabilidade. Chamar o construtor sem usar o operador novo é viável.

Novo operador

A demanda por alocação de memória no armazenamento aberto é indicado pelo novo operador. Se a memória suficiente for acessível, um novo operador processa dados. Em seguida, inicialize e dá ao objeto Ponteiro o endereço da memória recentemente alocada e configurada.

Exemplo 1

Executamos esse código para mostrar como os operadores novos e excluídos podem ser utilizados; A memória será alocada dinamicamente e liberada.

#incluir
usando namespace std;
int main ()

int* a = null;
a = novo (nada) int;
se (!a)
cout << "Memory is not allocated\n";
outro

*a = 45;
cout << "Value of a: " << *a << endl;

Float *c = novo flutuador (67.84);
cout << "Value of c: " << *c << endl;
int x = 6;
int *b = new (nada) int [x];
se (!b)
cout << "Memory is not allocated\n";
outro

for (int j = 0; j < x; j++)
b [j] = j+1;
cout << "A chunk of memory containing values: ";
for (int j = 0; j < x; j++)
cout << b[j] << " ";

excluir um;
excluir c;
excluir [] b;
retornar 0;

As bibliotecas necessárias seriam integradas. Em seguida, o espaço para nome padrão será adicionado como 'std'. Aqui, a função principal () seria invocada. Inicializaríamos um ponteiro e definiríamos este ponteiro como 'nulo'. Vamos solicitar armazenar as variáveis ​​utilizadas para um operador 'novo'. O tipo de dados de 'a' será 'inteiro'. A condição 'se-else' se aplicaria. Se a condição definida for satisfeita, a declaração 'cout' exibirá o texto 'a memória não será alocada'. Caso contrário, armazenaríamos o valor do ponteiro.

Então, o comando 'cout' mostra o valor do ponteiro. Agora, solicitaríamos um bloco de memória utilizando o 'novo' operador. Especificamos o valor do ponto flutuante da variável 'C' usando o operador 'novo'. Agora, o 'cout' imprimirá o valor da variável 'C'. Aqui, especificamos o tamanho do bloco de memória. Declaramos uma variável 'x' e definimos seu tipo de dados como um 'número inteiro'. Construímos um novo ponteiro chamado 'b' e fornecemos o valor usando o operador 'novo'.

Mais uma vez, a condição 'if-else' será utilizada. Dentro da declaração 'else', usamos a declaração 'para'. Inicialmente, a variável de loop 'J' seria declarada e definimos a condição. Em seguida, aumentamos o valor da variável de loop por 1. O comando 'cout' seria usado para imprimir a linha 'um pedaço de memória contendo valores'. Mais uma vez, empregaremos o loop 'para'.

Agora, liberaremos a memória alocada pela utilização do operador 'excluir'. Antes de adicionar o comando 'retornar 0', liberamos o bloco de memória alocada usando a matriz.

Adquirimos esse tipo de resultado após a execução do programa acima mencionado.

Exemplo 2

Nesse caso, utilizaremos o operador 'novo' para diferentes objetos.

#incluir
#incluir
usando namespace std;
int main ()

int *l = null;
l = new int ();
int *v = new int (23);
se(!eu)

cout<<"bad memory allocation"<
outro

cout<<"memory allocated successfully"<*l = 20;
cout<<"*l = "<<*l<cout<<"*v = "<<*v<
duplo *arr = null;
arr = novo duplo [20];
se(!arr)
cout<<"memory not allocated"<outro

para (int k = 0; k<20;k++)
arr [k] = k+1;
cout<<"arr values : ";
para (int k = 0; k<20;k++)
cout<< arr[k]<<"\t";

excluir l;
excluir v;
excluir [] arr;
retornar 0;

Na ilustração está a integração das bibliotecas necessárias . Em seguida, o espaço para nome conhecido como "std" será adicionado. O método principal () seria chamado. Para inicializar um ponteiro, nós o definiríamos como “nulo.”O valor da variável“ i ”que é usado para o“ novo ”operador seria armazenado aqui. O tipo de dados desta variável é “Inteiro."A condição" se-else "será utilizada. Se a condição especificada for atendida, o texto “Alocação de memória ruim” será exibida pela instrução “Cout”. Caso contrário, manteríamos o valor do ponteiro.

Em seguida, o texto “Memória alocada com sucesso” é exibida usando o comando “cout”. O valor do ponteiro seria definido. O valor do ponteiro seria exibido pelo comando 'cout'. Inicializamos a matriz com o tipo de dados "duplo" e demos o valor "nulo.”Usando o operador 'novo', definimos o valor desta matriz. Ele usa uma declaração "if-else". Quando a condição é atendida, o comando "cout" imprime "a memória não alocada.”; caso contrário, usamos declarações aninhadas "para".

Antes de definir a condição, a variável de loop "j" seria especificada primeiro. Em seguida, adicionamos 1 ao valor de 'J'. Os valores da matriz seriam impressos usando o comando 'cout'. Nós usaríamos o loop "for" mais uma vez. Agora, usaremos o operador de exclusão. Vamos liberar a memória que foi alocada. Lançamos o bloco de memória alocada, utilizando a matriz antes de adicionar a instrução "Return 0".

Depois de implementar o código acima mencionado, obtemos o resultado desejado.

Conclusão

O uso do operador 'novo' é o foco deste artigo. Para tipos de dados definidos pelo usuário em classes e outros tipos de dados, utilizaremos o 'novo' operador. Nós executamos dois exemplos relacionados a este tópico. O primeiro exemplo demonstra como usar o operador 's' s 's' s 's'. A última ilustração mostra como aplicar o “novo” operador aos objetos.