Dynamic Memory Management

Introduction
After writing a C++ application, your application is given a certain amount of memory to use,
which is divided into three segments as follows:
o Code Segment, in which all the application code is stored
o Data Segment, that holds the global data
o Stack Segment, used as a container for local variables and other temporary information.
In addition to these, the operating system also provides an extra amount of memory called Heap
also called free store.
The problem with local variables is that they don't persist: When the function returns, the local
variables are thrown away. Global variables solve that problem at the cost of unrestricted access
throughout the program, which leads to the creation of code that is difficult to understand and
maintain. Putting data in the free store solves both of these problems.
You can think of the free store as a massive section of memory in which thousands of
sequentially numbered cells waiting for your data. You can't label these cells, though, as you can
with the stack. You must ask for the address of the cells that you reserve and then store that
address in a pointer.
The stack segment is cleaned automatically when a function returns. All the local variables go
out of scope, and they are removed from the stack. The free store is not cleaned until your
program ends, and it is your responsibility to free any memory that you've reserved when you are
done with it.
The advantage to the free store is that the memory you reserve remains available until you
explicitly free it. If you reserve memory on the free store while in a function, the memory is still
available when the function returns.
The advantage of accessing memory in this way, rather than using global variables, is that only
functions with access to the pointer have access to the data. This provides a tightly controlled
interface to that data, and it eliminates the problem of one function changing that data in
unexpected and unanticipated ways. For this to work, you must be able to create a pointer to an
area on the free store and to pass that pointer among functions. The following sections describe
how to do this.

1
new
You allocate memory on the free store in C++ by using the new keyword. new is followed by the
type of the object that you want to allocate so that the compiler knows how much memory is
required. Therefore, new int allocates two bytes in the free store, and new long allocates four.
The return value from new is a memory address. It must be assigned to a pointer. To create an int
on the free store, you might write
int * pPointer;
pPointer = new int;
You can, of course, initialize the pointer at its creation with
int * pPointer = new int(10);
In either case, pPointer now points to an int on the free store. You can use this like any other
pointer to a variable and assign a value into that area of memory by writing
*pPointer = 72;
Or it can be written as
int * pPointer = new int (72);
This means, "Put 72 at the value in pPointer," or "Assign the value 72 to the area on the free store
to which pPointer points."
If new cannot create memory on the free store (memory is, after all, a limited resource) it returns
the null pointer. You must check your pointer for null each time you request new memory.
WARNING: Each time you allocate memory using the new keyword, you must check to make
sure the pointer is not null.
delete
When you are finished with your area of memory, you must call delete on the pointer. delete
returns the memory to the free store. Remember that the pointer itself--as opposed to the memory
to which it points--is a local variable. When the function in which it is declared returns, that
pointer goes out of scope and is lost. The memory allocated with new is not freed automatically,
however. That memory becomes unavailable--a situation called a memory leak. It's called a
memory leak because that memory can't be recovered until the program ends. It is as though the
memory has leaked out of your computer.
To restore the memory to the free store, you use the keyword delete. For example,
delete pPointer;

2
When you delete the pointer, what you are really doing is freeing up the memory whose address
is stored in the pointer. You are saying, "Return to the free store the memory that this pointer
points to." The pointer is still a pointer, and it can be reassigned. The following program
demonstrates allocating a variable on the heap, using that variable, and deleting it.
1: // Listing 8.4
2: // Allocating and deleting a pointer
3:
4: #include <iostream.h>
5: int main()
6: {
7: int localVariable = 5;
8: int * pLocal= &localVariable;
9: int * pHeap = new int;
10: if (pHeap == NULL)
11: {
12: cout << "Error! No memory for pHeap!!";
13: return 0;
14: }
15: *pHeap = 7;
16: cout << "localVariable: " << localVariable << "\n";
17: cout << "*pLocal: " << *pLocal << "\n";
18: cout << "*pHeap: " << *pHeap << "\n";
19: delete pHeap;
20: pHeap = new int;
21: if (pHeap == NULL)
22: {
23: cout << "Error! No memory for pHeap!!";
24: return 0;
25: }
26: *pHeap = 9;
27: cout << "*pHeap: " << *pHeap << "\n";
28: delete pHeap;
29: return 0;
30: }

Output: localVariable: 5
*pLocal: 5
*pHeap: 7
*pHeap: 9
Analysis: Line 7 declares and initializes a local variable. Line 8 declares and initializes a pointer
with the address of the local variable. Line 9 declares another pointer but initializes it with the
result obtained from calling new int. This allocates space on the free store for an int. Line 10
verifies that memory was allocated and the pointer is valid (not null). If no memory can be
3
allocated, the pointer is null and an error message is printed.
To keep things simple, this error checking often won't be reproduced in future programs, but you
must include some sort of error checking in your own programs.
Line 15 assigns the value 7 to the newly allocated memory. Line 16 prints the value of the local
variable, and line 17 prints the value pointed to by pLocal. As expected, these are the same. Line
19 prints the value pointed to by pHeap. It shows that the value assigned in line 15 is, in fact,
accessible.
In line 19, the memory allocated in line 9 is returned to the free store by a call to delete. This frees
the memory and disassociates the pointer from that memory. pHeap is now free to point to other
memory. It is reassigned in lines 20 and 26, and line 27 prints the result. Line 28 restores that
memory to the free store.
Although line 28 is redundant (the end of the program would have returned that memory) it is a
good idea to free this memory explicitly. If the program changes or is extended, it will be
beneficial that this step was already taken care of.
WARNING: When you call delete on a pointer, the memory it points to is freed. Calling delete on
that pointer again will crash your program! When you delete a pointer, set it to zero (null).
Calling delete on a null pointer is guaranteed to be safe. For example:
Animal *pDog = new Animal;
delete pDog; //frees the memory
pDog = 0; //sets pointer to null //... delete pDog; //harmless
Another way you might inadvertently create a memory leak is by reassigning your pointer before
deleting the memory to which it points. Consider this code fragment:
1: float * pPointer = new float;
2: *pPointer = 72.0;
3: pPointer = new float;
4: *pPointer = 84.5;
Line 1 creates pPointer and assigns it the address of an area on the free store. Line 2 stores the
value 72 in that area of memory. Line 3 reassigns pPointer to another area of memory. Line 4
places the value 84 in that area. The original area--in which the value 72 is now held--is
unavailable because the pointer to that area of memory has been reassigned. There is no way to
access that original area of memory, nor is there any way to free it before the program ends.
The code should have been written like this:

4
 1: float * pPointer = new float;
2: *pPointer = 72;
3: delete pPointer;
4: pPointer = new float;
5: *pPointer = 84;
Now the memory originally pointed to by pPointer is deleted, and thus freed, in line 3.
NOTE: For every time in your program that you call new, there should be a call to delete. It is
important to keep track of which pointer owns an area of memory and to ensure that the memory
is returned to the free store when you are done with it.
C++ also provides the possibility to allocate an entire array in the heap, keeping a pointer to its
first element. Again we use the new operator but mention the size of the array in square brackets:
int *table;
table = new int[100];
This will allocate 100 * sizeof(int) = 100 * 4 = 400 bytes of memory and assign the starting
address of the memory block to the table pointer.
Arrays allocated in the heap are similar to those allocated in the data or stack segments, so we
may access an arbitrary element using the indexing operator []. For example the next loop
initializes each element of the array to zero:
For (int i = 0; i < 100; i++)
table[i]=0;
Bad news is C++ does not provide any method of initializing heap arrays as you would an
ordinary dynamic variable, so we have to do it ourselves using a loop similar to the one above.
The following line will generate errors at compilation :
table = new int[100](0);
To erase a heap-allocated array we will use the delete operator, but this time add a pair of square
brackets so that the compiler can differentiate it from an ordinary dynamic variable.
delete [] table;