Sometimes
you know the exact quantity, type, and lifetime
of the objects in your program. But not always.
How
many planes will an air-traffic system have to handle? How many shapes will a
CAD system need? How many nodes will there be in a network?
To
solve the general programming problem, it’s essential that you be able to
create and destroy objects at runtime. Of course, C has always provided the
dynamic
memory allocation
functions
malloc( )and
free( )(along
with variants of
malloc( ))
that allocate storage from the
heap
(also called the
free
store
)
at runtime.
However,
this simply won’t work in C++. The constructor doesn’t
allow you to hand it the address of the memory to initialize, and for good
reason: If you could do that, you might
Forget.
Then guaranteed initialization
of
objects in C++ wouldn’t be guaranteed.
Accidentally
do something to the object before you initialize it, expecting the right thing
to happen.
Hand
it the wrong-sized object.
And
of course, even if you did everything correctly, anyone who modifies your
program is prone to the same errors. Improper initialization is responsible for
a large portion of programming errors, so it’s especially important to
guarantee constructor calls for objects created on the heap.
So
how does C++ guarantee proper initialization and cleanup, but allow you to
create objects dynamically, on the heap?
The
answer is, “by bringing dynamic object creation into the core of the
language.”
malloc( )
and
free( )
are library functions, and thus outside the control of the compiler. However,
if you have an
operator
to perform the combined act of dynamic storage allocation and initialization
and another to perform the combined act of cleanup and releasing storage, the
compiler can still guarantee that constructors and destructors will be called
for all objects.
In
this chapter, you’ll learn how C++’s
new
and
delete
elegantly solve this problem by safely creating objects on the heap.