memória dinâmica C ++

Compreender a dinâmica de memória em C ++ é a forma como o trabalho é para se tornar um qualificado C ++ programadores essenciais. C ++ memória de programa é dividido em duas partes:

• Empilhar: todas as variáveis declaradas dentro de uma função ocupará a memória de pilha.
• Heap: Esta é amemória de programa não é usado, o programa é executado pode ser utilizado para alocar dinamicamente memória.

Muitas vezes, não é possível prever com antecedência a quantidade de memória necessária para armazenar uma variável definida na informação específica necessária para determinar o tamanho de memória necessária em tempo de execução.

Em C ++, você pode usar um operador especial é atribuído a uma variável de um determinado tipo de memória dentro da pilha em tempo de execução, ele retorna o espaço de endereço alocado. Este operador é sernovo operador.

Se você não precisa alocar dinamicamente a memória, você pode usar o operador deexclusão, excluídos pelo novo operador antes de a memória alocada.

operadores new e delete

Aqui está o novo operador para ser qualquer sintaxe geral do tipo de dados alocação dinâmica de memória:

new data-type;

Aqui, tipo de dados pode ser qualquer built-in tipos de dados, incluindo matrizes, pode ser qualquer tipo de dados, incluindo uma classe ou estrutura, incluindo definida pelo usuário.Vamos primeiro olhar para os tipos de dados embutidos. Por exemplo, podemos definir um ponteiro para um ponteiro do tipo double, em seguida, solicita memória, a memória é alocada em tempo de execução. Nós podemos usar onovo operador, em conformidade com a seguinte instrução para fazer isso:

double* pvalue  = NULL; // 初始化为 null 的指针
pvalue  = new double;   // 为变量请求内存

Se as áreas de armazenamento gratuitos foram esgotados, não podem atribuir com sucesso memória. É aconselhável verificar se o novo operador retorna um ponteiro NULL, e tomar as medidas adequadas a seguinte:

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

}

funçãomalloc () na linguagem C apareceu em C ++ ainda está presente, mas recomenda-se não usar malloc () função.função nova e malloc () em comparação com a sua principal vantagem é que, não só alocar nova memória, ele também criou o objeto.

A qualquer momento, quando você sente que um variáveis ​​dinâmicas de memória já alocada não é mais necessário, você pode usar o operador delete para liberar a memória que ele usado, como segue:

delete pvalue;        // 释放 pvalue 所指向的内存

Usado no conceito acima, o seguinte exemplo demonstra como usar o novo e excluir operadores:

#include <iostream>
using namespace std;

int main ()
{
   double* pvalue  = NULL; // 初始化为 null 的指针
   pvalue  = new double;   // 为变量请求内存
 
   *pvalue = 29494.99;     // 在分配的地址存储值
   cout << "Value of pvalue : " << *pvalue << endl;

   delete pvalue;         // 释放内存

   return 0;
}

Quando o código acima é compilado e executado, ele produz os seguintes resultados:

Value of pvalue : 29495

Uma matriz de alocação de memória dinâmica

Suponha que queremos uma matriz de caracteres (uma seqüência de 20 caracteres) para alocar memória, podemos usar o exemplo acima de sintaxe de matriz para alocar dinamicamente a memória, como segue:

char* pvalue  = NULL;   // 初始化为 null 的指针
pvalue  = new char[20]; // 为变量请求内存

Para excluir uma matriz que acabamos de criar, a declaração é a seguinte:

delete [] pvalue;        // 删除 pvalue 所指向的数组

Aqui está o novo operador sintaxe geral pode alocar memória para os arrays multidimensionais, como segue:

int ROW = 2;
int COL = 3;
double **pvalue  = new double* [ROW]; // 为行分配内存

// 为列分配内存
for(int i = 0; i < COL; i++) {
    pvalue[i] = new double[COL];
}

Liberar memória matriz multidimensional:

for(int i = 0; i < COL; i++) {
    delete[] pvalue[i];
}
delete [] pvalue; 

objeto alocação de memória dinâmica

O objeto não é diferente de tipos de dados simples. Por exemplo, considere o seguinte código, vamos usar uma matriz de objetos para esclarecer este conceito:

#include <iostream>
using namespace std;

class Box
{
   public:
      Box() { 
         cout << "调用构造函数！" <<endl; 
      }
      ~Box() { 
         cout << "调用析构函数！" <<endl; 
      }
};

int main( )
{
   Box* myBoxArray = new Box[4];

   delete [] myBoxArray; // Delete array

   return 0;
}

Se você quer uma caixa contém quatro objetos alocar matriz de memória, o construtor será chamado quatro vezes, da mesma forma, quando você excluir esses objetos, o destruidor será chamado o mesmo número de vezes (quatro vezes).

Quando o código acima é compilado e executado, ele produz os seguintes resultados:

调用构造函数！
调用构造函数！
调用构造函数！
调用构造函数！
调用析构函数！
调用析构函数！
调用析构函数！
调用析构函数！