Gerenciamento de memória: Exemplos

Artigo
08/25/2010

Este artigo descreve como MFC executa alocações de quadro e as alocações de heap para cada um os três tipos típicos de alocações de memória:

Uma matriz de bytes
Uma estrutura de dados
Um objeto

Alocação de uma matriz de bytes

Para alocar uma matriz de bytes no quadro

Definir a matriz sistema autônomo mostrados pelo código a seguir.O array é automaticamente excluído e sua memória recuperado quando a matriz variável sai de seu escopo.
```
{
   const int BUFF_SIZE = 128; 

   // Allocate on the frame
   char myCharArray[BUFF_SIZE];
   int myIntArray[BUFF_SIZE];
   // Reclaimed when exiting scope 
}
```

Alocar uma matriz de bytes (ou qualquer tipo de dados primitivos) sobre o heap

Use o novo operador com a sintaxe de matriz mostrada neste exemplo:

const int BUFF_SIZE = 128;

// Allocate on the heap
char* myCharArray = new char[BUFF_SIZE]; 
int* myIntArray = new int[BUFF_SIZE];

Para desalocar os arrays do heap

Use o Excluir operador sistema autônomo segue:

delete [] myCharArray;
delete [] myIntArray;

Alocação de uma estrutura de dados

Para alocar uma estrutura de dados no quadro

Definir a variável estrutura sistema autônomo segue:

struct MyStructType { int topScore; };
void MyFunc()
{
    // Frame allocation
    MyStructType myStruct;

    // Use the struct 
    myStruct.topScore = 297;

    // Reclaimed when exiting scope
}

A memória ocupada pela estrutura é recuperada quando ele sai de seu escopo.

Alocar estruturas de dados sobre o heap

Use novo para alocar estruturas de dados na pilha e Excluir para desalocar, sistema autônomo mostrado pelos exemplos a seguir:

// Heap allocation
MyStructType* myStruct = new MyStructType;

// Use the struct through the pointer ...
myStruct->topScore = 297;

delete myStruct;

Alocação de um objeto

Para alocar um objeto no quadro

Declare o objeto da seguinte maneira:
```
{
   CMyClass myClass;     // Automatic constructor call here

   myClass.SomeMemberFunction();     // Use the object
}
```
O destruidor do objeto é invocado automaticamente quando o objeto sai do seu escopo.

Para alocar um objeto no heap

Use o novo operador, que retorna um ponteiro para o objeto, alocar objetos no heap.Use o Excluir operador excluí-los.

Os exemplos de heap e quadro a seguir pressupõem que o CPerson construtor utiliza sem argumentos.
```
// Automatic constructor call here
CMyClass* myClass = new CMyClass;  

myClass->SomeMemberFunction();  // Use the object

delete myClass;  // Destructor invoked during delete
```
Se o argumento para o CPerson construtor é um ponteiro para char, a demonstrativo de distribuição de quadro é:
```
CMyClass myClass("Joe Smith");
```
A demonstrativo de alocação de heap é:
```
CMyClass* myClass = new CMyClass("Joe Smith");
```

Consulte também

Conceitos

Gerenciamento de memória: Alocação de heap

Partilhar via