Allocating memory in the heap
To allocate memory for
a variable of type T, use expression
new T.
It allocates the required memory and returns its
address (a pointer). For example,
int* pi = new int; double* pd = new double;makes variable pi point to a newly allocate chunk of memory big enough to hold one int, and pd point to newly allocated memory big enough for a value of type double. |
Deallocating memory in the heap
If pointer p was given to you by an expression of the form
new T, then statement
delete p;deallocates the memory pointed to by p. (It does not destroy p itself.) Really, it just recycles the memory. The heap manager takes ownership of the memory, and it might give that same memory back to you at a future use of new. Important note. Only delete a pointer that was given to you by new. Never try to delete a local variable of a function. |
Allocating memory in C
Although we are using C++, it is worth mentioning that the
new operator is not part of C. To allocate memory in
the heap in a C program, you use a more primitive mechanism: a call
to a function called malloc, which takes one argument, the number
of bytes to allocate, and returns a pointer of type
void*
to a newly allocated chunk of that many bytes. Statements
int* p = (int*) malloc(sizeof(int)); double* q = (double*) malloc(sizeof(double));are similar to the statements above that allocate using new. For any type T, sizeof(T) is the number of bytes that a variable of type T needs. |
Deallocating memory in C
If p is a pointer that was given to you using malloc, then
statement
free(p);gives the memory pointed to by p back to the heap manager. |
Only deallocate memory when you are truly finished with that memory. If you have more than one pointer to a chunk of memory, then deallocating that chunk makes all pointers to it stale; they are pointing to memory that you are no longer allowed to use. Those pointers are called dangling pointers. |
Watch out: no automatic deallocation in the heap
Some languages, such as Java, use garbage collectors
that periodically go through the heap and recycle chunks of
memory that are not being used. That does not happen
in a C++ program. If you lose all pointers to a chunk of memory
without deallocating that memory then you have a
memory leak.
Your program will continue to own that
memory, but has no way of ever using it again. A very small memory
leak is not a problem. But if a program allocates a lot of
memory and never deallocates it, the program's memory footprint
will grow and grow.
When your program stops, all of the memory that it owns is automatically recovered by the operating system. So a memory leak is only relevant while a program is running; it does not affect the system after the program stops. |
Write a statement that creates variable p of type long* and makes p point to newly allocated memory of type long. Use the C++ method of allocating memory. Answer
Suppose that the memory pointed to by p from the preceding question is no longer needed. Write a statement that deallocates that memory. Answer
What is a memory leak? Answer
What are the consequences of a memory leak? Answer
Is the following function a suitable substitute for the new operator for allocating new memory to hold one int?
int* newInt() { int n; return &n; }That is, can you use
int* p = newInt();instead of
int* p = new int;Answer