|
The need for containers
Obviously, an integer stack isn’t a
crucial tool. The real need for containers comes when you start making objects
on the heap using new and destroying them with delete. In the
general programming problem, you don’t know how many objects you’re
going to need while you’re writing the program. For example, in an
air-traffic control system you don’t want to limit the number of planes
your system can handle. You don’t want the program to abort just because
you exceed some number. In a computer-aided design system, you’re dealing
with lots of shapes, but only the user determines (at runtime) exactly how many
shapes you’re going to need. Once you notice this tendency, you’ll
discover lots of examples in your own programming situations.
C programmers who rely on virtual memory
to handle their “memory management” often find the idea of
new,
delete, and container classes disturbing. Apparently, one practice in C
is to create a huge global array, larger than anything the program would appear
to need. This may not require much thought (or awareness of
malloc( ) and free( )), but it produces programs that
don’t port well and that hide subtle bugs.
In addition, if you create a huge global
array of objects in C++, the constructor and destructor overhead can slow things
down significantly. The C++ approach works much better: When you need an object,
create it with new, and put its pointer in a container. Later on, fish it
out and do something to it. This way, you create only the objects you absolutely
need. And usually you don’t have all the initialization conditions
available at the start-up of the program. new allows you to wait until
something happens in the environment before you can actually create the
object.
So in the most common situation,
you’ll make a container that holds pointers to some objects of interest.
You will create those objects using new and put the resulting pointer in
the container (potentially upcasting it in the process), pulling it out later
when you want to do something with the object. This technique produces the most
flexible, general sort of
program.
|
|