Memory Management

Memory management concerns in C++ fall into two general camps: getting it right and making it perform
efficiently. Good programmers understand that these concerns should be addressed in that order, because a
program that is dazzlingly fast and astoundingly small is of little use if it doesn't behave the way it's supposed to.
For most programmers, getting things right means calling memory allocation and deallocation routines correctly.
Making things perform efficiently, on the other hand, often means writing custom versions of the allocation and
deallocation routines. Getting things right there is even more important.

On the correctness front, C++ inherits from C one of its biggest headaches, that of potential memory leaks. Even
virtual memory, wonderful invention though it is, is finite, and not everybody has virtual memory in the first
place.

In C, a memory leak arises whenever memory allocated through malloc is never returned through free. The
names of the players in C++ are new and delete, but the story is much the same. However, the situation is
improved somewhat by the presence of destructors, because they provide a convenient repository for calls to
delete that all objects must make when they are destroyed. At the same time, there is more to worry about,
because new implicitly calls constructors and delete implicitly calls destructors. Furthermore, there is the
complication that you can define your own versions of operator new and operator delete, both inside and outside
of classes. This gives rise to all kinds of opportunities to make mistakes.