Chapter
4 made a significant improvement in library use by taking all the scattered
components of a typical C library and encapsulating them into a structure (an
abstract data type, called a
class
from now on).
This
not only provides a single unified point of entry into a library component, but
it also hides the names of the functions within the class name. In Chapter 5,
access control (implementation hiding) was introduced. This gives the class
designer a way to establish clear boundaries for determining what the client
programmer is allowed to manipulate and what is off limits. It means the
internal mechanisms of a data type’s operation are under the control and
discretion of the class designer, and it’s clear to client programmers
what members they can and should pay attention to.
Together,
encapsulation and implementation hiding make a significant step in improving
the ease of library use. The concept of “new data type” they
provide is better in some ways than the existing built-in data types from C.
The C++ compiler can now provide type-checking guarantees for that data type
and thus ensure a level of safety when that data type is being used.
When
it comes to safety, however, there’s a lot more the compiler can do for
us than C provides. In this and future chapters, you’ll see additional
features that have been engineered into C++ that make the bugs in your program
almost leap out and grab you, sometimes before you even compile the program,
but usually in the form of compiler warnings and errors. For this reason, you
will soon get used to the unlikely-sounding scenario that a C++ program that
compiles usually runs right the first time.
Two
of these safety issues are initialization and cleanup. A large segment of C
bugs occur when the programmer forgets to initialize or clean up a variable.
This is especially true with C libraries, when client programmers don’t
know how to initialize a
struct,
or even that they must. (Libraries often do not include an initialization
function, so the client programmer is forced to initialize the
struct
by hand.) Cleanup is a special problem because C programmers are comfortable
with forgetting about variables once they are finished, so any cleaning up that
may be necessary for a library’s
struct
is often missed.
In
C++ the concept of initialization and cleanup is essential for easy library use
and to eliminate the many subtle bugs that occur when the client programmer
forgets to perform these activities. This chapter examines the features in C++
that help guarantee proper initialization and cleanup.