Gerenciamento de memória: exemplos

Este artigo descreve como o MFC executa alocações de quadros e alocações de heap para cada um dos 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

1. Defina a matriz conforme mostrado pelo código a seguir. A matriz é excluída automaticamente e sua memória recuperada quando a variável de matriz 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 
   }
   

Para alocar uma matriz de bytes (ou qualquer tipo de dados primitivo) no montão

1. Use o new 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 as matrizes da pilha

1. Use o delete operador da seguinte maneira:

   delete[] myCharArray;
   delete[] myIntArray;
   

Alocação de uma estrutura de dados

Para alocar uma estrutura de dados no quadro

1. Defina a variável de estrutura da seguinte forma:

   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 é libertada quando ela sai do seu escopo.

Para alocar estruturas de dados no heap

1. Use new para alocar estruturas de dados no heap e delete para desalocar estruturas de dados, 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

1. 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 de seu escopo.

Para alocar um objeto na pilha

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

   Os exemplos de heap e frame a seguir assumem que o CPerson construtor não usa 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 for um ponteiro para char, a instrução para alocação de quadro é:

   CMyClass myClass("Joe Smith");
   

   A declaração para alocação de heap é:

   CMyClass* myClass = new CMyClass("Joe Smith");
   

Ver também

Gestão de memória: alocação de heap