HP Integrity NonStop H-Series - Manual (Page 51)

Click on the banner to return to the user guide home page.
©Copyright 1996 Rogue Wave Software
Memory Management Issues
Containers in the standard library can maintain a variety of different types of elements. These
include the fundamental data types (integer, char, and so on), pointers, or user-defined types.
Containers cannot hold references. In general, memory management is handled automatically
by the standard container classes, with little interaction by the programmer.
Values are placed into a container using the copy constructor. For most container classes, the
element type held by the container must also define a default constructor. Generic algorithms
that copy into a container (such as copy()) use the assignment operator.
When an entire container is duplicated (for example, through invoking a copy constructor or as
the result of an assignment), every value is copied into the new structure using (depending on
the structure) either the assignment operator or a copy constructor. Whether such a result is a
"deep copy" or a "shallow copy," it is controlled by the programmer, who can provide the
assignment operator with whatever meaning is desired. Memory for structures used internally
by the various container classes is allocated and released automatically and efficiently.
If a destructor is defined for the element type, this destructor will be invoked when values are
removed from a container. When an entire collection is destroyed, the destructor will be
invoked for each remaining value being held by the container.
A few words should be said about containers that hold pointer values. Such collections are not
uncommon. For example, a collection of pointers is the only way to store values that can
potentially represent either instances of a class or instances of a subclass. Such a collection is
encountered in an example problem discussed in
Chapter 11 ( Application - Event Driven Simulation ) .
In these cases the container is responsible only for maintaining the pointer values themselves. It
is the responsibility of the programmer to manage the memory for the values being referenced
by the pointers. This includes making certain the memory values are properly allocated (usually
by invoking the new operator), that they are not released while the container holds references to
them, and that they are properly released once they have been removed from the container.