Gerenciamento de memória: exemplos

Artigo
06/16/2023

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

Defina a matriz conforme mostrado no código a seguir. A matriz é excluída automaticamente e sua memória é recuperada 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 qualquer tipo de dados primitivo) no heap

Use o operador new 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 as matrizes do heap

Use o operador delete da seguinte maneira:

delete[] myCharArray;
delete[] myIntArray;

Alocação de uma estrutura de dados

Para alocar uma estrutura de dados no quadro

Defina a variável de estrutura da seguinte maneira:

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 ela sai do escopo.

Para alocar estruturas de dados no heap

Use new para alocar estruturas de dados no heap e delete para desalocá-las, conforme mostrado pelos seguintes exemplos:

// 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 escopo.

Para alocar um objeto no heap

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

Os exemplos de heap e quadro a seguir pressupõem que o construtor CPerson não aceita 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 CPerson for um ponteiro para char, a instrução para alocação de quadros será:
```
CMyClass myClass("Joe Smith");
```
A instrução para alocação de heap é:
```
CMyClass* myClass = new CMyClass("Joe Smith");
```

Confira também

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

Partilhar via