Memory Management: Examples

This article describes how MFC performs frame allocations and heap allocations for each of the three typical kinds of memory allocations:

Allocation of an Array of Bytes

To allocate an array of bytes on the frame

  1. Define the array as shown by the following code. The array is automatically deleted and its memory reclaimed when the array variable exits its scope.

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

To allocate an array of bytes (or any primitive data type) on the heap

  1. Use the new operator with the array syntax shown in this example:

    const int BUFF_SIZE = 128;
    
    // Allocate on the heap
    char* myCharArray = new char[BUFF_SIZE]; 
    int* myIntArray = new int[BUFF_SIZE];
    

To deallocate the arrays from the heap

  1. Use the delete operator as follows:

    delete [] myCharArray;
    delete [] myIntArray;
    

Allocation of a Data Structure

To allocate a data structure on the frame

  1. Define the structure variable as follows:

    struct MyStructType { int topScore; };
    void MyFunc()
    {
        // Frame allocation
        MyStructType myStruct;
    
        // Use the struct 
        myStruct.topScore = 297;
    
        // Reclaimed when exiting scope
    }
    

    The memory occupied by the structure is reclaimed when it exits its scope.

To allocate data structures on the heap

  1. Use new to allocate data structures on the heap and delete to deallocate them, as shown by the following examples:

    // Heap allocation
    MyStructType* myStruct = new MyStructType;
    
    // Use the struct through the pointer ...
    myStruct->topScore = 297;
    
    delete myStruct;	
    

Allocation of an Object

To allocate an object on the frame

  1. Declare the object as follows:

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

    The destructor for the object is automatically invoked when the object exits its scope.

To allocate an object on the heap

  1. Use the new operator, which returns a pointer to the object, to allocate objects on the heap. Use the delete operator to delete them.

    The following heap and frame examples assume that the CPerson constructor takes no arguments.

    // Automatic constructor call here
    CMyClass* myClass = new CMyClass;  
    
    myClass->SomeMemberFunction();  // Use the object
    
    delete myClass;  // Destructor invoked during delete
    

    If the argument for the CPerson constructor is a pointer to char, the statement for frame allocation is:

    CMyClass myClass("Joe Smith");
    

    The statement for heap allocation is:

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

See Also

Memory Management: Heap Allocation