Compartilhar via


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:

Alocação de uma matriz de bytes

Para alocar uma matriz de bytes no quadro

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

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

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

  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 destruidor do objeto é invocado automaticamente 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 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