C++ objects and other variables are stored in one of three places. The static area is allocated at compile time, and includes things declared static, along with storage for constants and other odds and ends known before the program starts. Normal variables are allocated on the stack, along with other record-keeping data used when calling functions. When the program starts a function, or enters any curly-braced block, it allocates some space on the stack, which is reclaimed when the block is left. The third storage area, which we haven't used much so far, is called the heap. Space is allocated and returned to the heap by explicit operations in the program. More specifically:

• Normal variables are created when the declaration is executed, and storage space is taken from the stack. Therefore, the space is freed at function return, or at the closing curly brace that ends the scope of the variable declaration.
• Space for objects (and other variables) may be allocated explicitly with the C++ new operation. This space comes from the heap. This space must be explicitly returned to the heap using a delete operation.

In Java, all objects are allocated on the heap using new, and Java uses a garbage collector to automatically free objects which are no longer in use.

C++ takes a different approach. Objects can be created on the stack, but sometimes you need to create them dynamically using new, much as in Java. C++ does not provide a generalized garbage collection service. As the cliche goes, it's complicated.

The C++ designers judge that memory management is not suited to a one-size-fits-all solution. The programmer should solve it in the best way for the problem at hand, and C++ provides several tools for this purpose. This is not complete insanity. General garbage collection is very expensive, and can cause great variation in the running times of a program's operations. This is a problem for real-time systems, which need predictable run-times.

On the other hand, the C++ approach is more trouble for the programmer, and introduces all sorts of pitfalls that simply don't exist in Java. But it follows from the differences in design philosophies. (In the case of C++, the first three design goals are “Run fast,” “Run really fast,” and “Don't do anything to slow down the program.”) Though C++ makes memory management the programmer's responsibility, it does provide some tools to do the job. Of particular interest:

• An object which allocates memory is responsible to see that it is deleted when needed. The standard libarary string class is a good example. When you create a string object, it also allocates space to hold the contents of the string. The amount of space grows and shrinks as you use the string. When you're done with the string, it deletes whatever storage it allocates, and so cleans up after itself. The user of the string class doesn't need to worry about this at all, because the class designer, with some help from the language itself, makes sure all the storage is freed.
• The C++ library also provides certain kinds of classes known as “smart pointers,” which provide some limited forms of garbage collection, simplifying life in userland. Smart pointers can be used directly in application code, or to help design classes to manage their own memory properly.

One note about the term heap. Don't confuse it with the data structure. Our “heap” refers to a a region of memory, having no specific layout. The name is probably chosen to contrast with the more ordered “stack.”

The null pointer value should be written nullptr since C++11. The constant zero will also work, since it automatically converts to null pointer. In plain C, the name NULL is often used, and you will frequently see this in C++. The null pointer converts automatically to boolean, so for pointer p, if(p) ... is equivalent to if(p == nullptr) ....

This section discusses memory management features available only in C++. The last subsection summarizes memory management in plain C.