Gerenciamento de memória: exemplos

Artigo
06/10/2015

Este artigo descreve como o MFC executa alocações de quadro e alocações de heap para cada um dos três tipos típicos de alocação 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

Define a matriz como mostra o código a seguir. A matriz é automaticamente excluída e sua memória são recuperadas quando a variável de matriz sai do escopo.

{
   const int BUFF_SIZE = 128; 

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

Para alocar uma matriz de bytes (ou de qualquer tipo de dados primitivo) no heap

Use o operador de new com a sintaxe da 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 as matrizes de heap

Use o operador de delete como segue:

delete [] myCharArray;
delete [] myIntArray;

Alocação de uma estrutura de dados

Para atribuir uma estrutura de dados no quadro

Defina a variável da estrutura como 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 são recuperadas quando sai do escopo.

Para atribuir estruturas de dados no heap

Use new para atribuir estruturas de dados no heap e em delete para desalocar-los, como mostram os 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 atribuir um objeto no quadro

Declare o objeto como segue:
```
{
   CMyClass myClass;     // Automatic constructor call here

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

Para atribuir um objeto no heap

Use o operador de new , que retorna um ponteiro para o objeto, atribuir objetos no heap. Use o operador de delete para excluí-los.

Os exemplos do heap e do quadro presumem que o construtor de CPerson não utiliza 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 construtor de CPerson é um ponteiro para char, a instrução para alocação do quadro é:
```
CMyClass myClass("Joe Smith");
```
A instrução da alocação de heap é:
```
CMyClass* myClass = new CMyClass("Joe Smith");
```

Consulte também

Conceitos

Gerenciamento de memória: alocação do heap

Compartilhar via