Gerenciamento de Memória: exemplos

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

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 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

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 do heap

1. Use o operador delete da seguinte forma:

   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 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

1. 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

1. Declare o objeto da seguinte maneira:

   {
   CMyClass myClass;     // Automatic constructor call here
   
   myClass.SomeMemberFunction();     // Use the object
   }
   

   O destrutor do objeto é automaticamente invocado quando o objeto sai do escopo.

Para alocar um objeto no heap

1. 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 frame a seguir pressupõem que o CPerson construtor não receba 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");
   

Consulte também

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