After the study of pointers versus references, the second natural question that comes in head of a ex Java developer turning to C++ is:
“What are the difference between static and dynamic memory allocation in C++?”
which can be translated as:
“When should I use the stack and when do I have to use the heap in C++?”
that can be further simplified to:
“When should I use the new operator in C++?”
I could simply summarize the answer to: “Use stack when possible”, but I think that this time there is the need of more explanations. Let’s have the following model for a process in the system:
A simplified model for a process
I’m not really interested in an real representation of a process (see Modern Operating Systems by A. S. Tanenbaum for a very good explanation on processes), but focus on the stack and on the heap.
In reality the heap is a software abstraction but you can also imagine it like the stack.
In C++ programs there are also several other memory areas in which objects and non-object values may be stored (see this article on GotW for further details).
Why then choose between stack or heap? Quoting my publication on object-oriented memory management in Java:
Stack-based variables have their extent determined by their scope, so the former is constrained by the structure of the code at compile-time .
Sometimes there is a need for the variables with unconstrained extent in order to cope with
problems where lifetime of a variable can only be known at run-time.
In this case heap-based variables, whose extent is strictly under control of the programmer, are used. [..]
I promise that I will update my 17 pages about OO-memory management to cover also C++ by the end of June. By the way, following some forums, wikipedia, my publication and GotW, I also summarized pros and cons of stack and heap use in C++:
| Stack |
Heap |
| Its size is determined at compile-time |
Size determined at run-time |
| Therefore, it is less expensive and quick |
Therefore, it is more expensive and slower than stack |
| The preferred way to store objects and variables if their size is limited. |
To be used only if needed: the amount of memory needed is variable and unknown, and may increase rapidly. |
| There is an AUTOMATIC CLEANUP of objects when they go out of their scope |
Objects STAY IN MEMORY even when you don’t use them anymore. |
| Programmers don’t have to bother to free resources |
Therefore, programmers HAVE TO CLEAN memory manually. However, all modern OS free the resources when the program exits. |
Update 2009-07-03
After 4 months of heavy GUI and Database C++ programming, here are my thoughts: if you are planning to write a program with something more than a couple of objects interacting, using associations and therefore, objects as attributes, use the heap. Every serious program, even if not really big, uses heap for object allocation. Just take care to delete the objects when you don’t need them anymore. Objects on the heap are dynamically allocated and it is more comfortable to pass them through other objects using pointers. The use of the heap assures the live of objects even if the method that generated them runs out of scope ( =dies ). If you also plan to write GUIs, solid toolkits like QT recommend the use of heap to create graphical objects.
In some Operating Systems, stack is also very limited while heap is usually not.
Here are listed the sources I used for writing this article:
- http://www.velocityreviews.com/forums/t278261-stack-vs-heap.html
- http://www.computing.net/answers/programming/stackheap-c/2293.html
- http://www.codeguru.com/forum/showthread.php?p=1186307#post1186307
- http://www.codeguru.com/forum/showthread.php?t=350945
- http://www.gotw.ca/gotw/009.htm
- http://en.wikipedia.org/wiki/Process_(computing)#Representation
- http://bd-things.net/object-oriented-memory-management/
Hope that this article helped you to clearly understand the differences between stack and heap allocation in C++, write me if there are other issues or you need more explanations!