Chapter
1 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 2,
access control (implementation hiding) was introduced. This gives the class
designer a way to establish clear boundaries for determining what the user 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 users 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 inherited
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 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 libraries, when users don’t know how to
initialize a
struct,
or even that they must. (Libraries often do not include an initialization
function, so the user is forced to initialize the
struct
by hand.) Cleanup is a special problem because C programmers are used to
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 to making library
use easy and to eliminating the many subtle bugs that occur when the user
forgets to perform these activities. This chapter examines the features in C++
that help guarantee proper initialization and cleanup.