One feature of object-oriented programming that is not found at all in procedural programming is the ability to define a hierarchy of types. In C++ you can define one class as a subtype, or special category, of another class by deriving it from that class. You can also express similarities between classes, or define them as subcategories of a single broad category, by deriving them all from one base class. By contrast, the C language treats all types as completely independent of one another.
Identifying a common base class for several classes is a form of abstraction. A base class is a high-level way to view those classes. It specifies what the derived classes have in common, so you can concentrate on those shared traits and ignore their individual characteristics. This abstraction technique lets you view entities in terms of a small number of categories instead of a large number. This technique is often used in everyday thinking; for example, it's easier to think “mammals” instead of “lions, tigers, bears...” and “bears” rather than “grizzly bears, black bears, polar bears....”
Whereas a base class is a generalization of a group of classes, a derived class is a specialization of another class. A derived class identifies a subtype of a previously recognized type, and describes it in terms of its additional characteristics. For example, lions are mammals, but they also have certain traits not found in all mammals.
There are two practical benefits of defining a class hierarchy: the derived class can share the base class's code, or it can share the base class's interface. These two benefits are not mutually exclusive, though a hierarchy designed for code reuse often has different characteristics from one designed to give a common interface.
If you are writing a class and want to incorporate the functionality of an existing class, you can simply derive your class from the existing one. This is a situation in which inheritance allows code reuse. For example, the Salesperson class in Chapter 7 incorporated the functionality of the WageEmployee class.
If you're implementing several classes at once that share features, a class hierarchy can reduce redundant coding. You can describe and implement those common features just once in a base class, rather than repeatedly in each derived class.
For example, consider a program for designing data entry forms, where users fill out fields onscreen. The program allows forms to contain fields that accept names, fields that accept dates, fields that accept monetary values, and so forth. Each field accepts only the appropriate type of data. You could make each type of field a separate class, with names like NameField, DateField, and MoneyField, each with its own criteria for validating input. Note that all the fields share some functionality. Each field is accompanied by a description telling the user what's requested, and the procedure for defining and displaying that description is the same for all fields. As a result, all the classes have identical implementations for their setPrompt, displayPrompt, and other functions.
You can save yourself effort as well as reduce the size of the program by defining a base class called Field that implements those functions. The NameField, DateField, and MoneyField classes can be derived from Field and inherit those functions. Such a class hierarchy also reduces the effort required to fix bugs or add features, because the changes only have to be made in one place.
A class hierarchy designed for code sharing has most of its code in the base classes (near the top of the hierarchy). This way the code can be reused by many classes. The derived classes represent specialized or extended versions of the base class.
Another inheritance strategy is for a derived class to inherit just the names of its base class's member functions, not the code; the derived class provides its own code for those functions. The derived class thus has the same interface as the base class but performs different things with the same functions.
This strategy lets different classes use the same interface, thus reinforcing the high-level similarity in their behavior. However, the main benefit of inheriting an interface is polymorphism, which was exhibited by the Employee class in Chapter 7. All the classes derived from Employee shared its interface, making it possible to manipulate them as generic Employee objects.
In the example of the data entry forms, Field has a member function called getValue, but the function doesn't do anything useful. NameField inherits that member function and provides it with code to validate input as a legal name. DateField and MoneyField do the same, each providing different code for the function. Thus, individual field objects may have various types and exhibit different behaviors, but they all share the same interface and can all be treated as Field objects.
A data entry form can simply maintain a list of Field objects and ignore the distinctions between types of fields. To read values into all the fields, a form can iterate through its list of Fields and call getValue for each without even knowing what types of fields are defined. The individual fields automatically get input using their own versions of getValue.
The example of the data entry forms uses inheritance for both code sharing and interface sharing. However, you can also design a class strictly for interface sharing by writing an abstract base class. The SortableObject class in Chapter 7 is an example of a class designed for pure interface sharing. The class's interface describes the necessary properties for an object to be stored in a SortedList object. However, the SortableObject class contains no code itself.
A class hierarchy designed for interface sharing has most of its code in the derived classes (near the bottom of the hierarchy). The derived classes represent working versions of an abstract model defined by the base class.
In summary, classes provide support for abstraction, encapsulation, and hierarchies. Classes are a mechanism for defining an abstract data type along with all the accompanying operations. Classes can be encapsulated, compartmentalizing your program and increasing its locality. Lastly, classes can be organized into hierarchies, highlighting their relationships to each other while letting you minimize redundant coding.
To gain the most benefit from object-oriented programming, you must do more than simply write your program in C++. The next section describes how you actually design an object-oriented program.