9

Object-Oriented
Programming:
Inheritance
Objectives
To be able to create classes by inheriting from existing
classes.
To understand how inheritance promotes software
reusability.
To understand the notions of base classes and derived
classes.
To understand the protected member-access
modifier.
To understand the use of constructors and destructors
in inheritance hierarchies.
Say not you know another entirely, till you have divided an
inheritance with him.
Johann Kasper Lavater
This method is to define as the number of a class the class of
all classes similar to the given class.
Bertrand Russell
A deck of cards was built like the purest of hierarchies, with
every card a master to those below it, a lackey to those above
it.
Ely Culbertson
Good as it is to inherit a library, it is better to collect one.
Augustine Birrell
Save base authority from others books.
William Shakespeare
610 Object-Oriented Programming: Inheritance Chapter 9

Outline
9.1 Introduction
9.2 Base Classes and Derived Classes
9.3 protected Members
9.4 Relationship between Base Classes and Derived Classes
9.5 Case Study: Three-Level Inheritance Hierarchy
9.6 Constructors and Destructors in Derived Classes
9.7 Uses A and Knows A Relationships
9.8 public, protected and private Inheritance
9.9 Software Engineering with Inheritance
9.10 [Optional Case Study] Thinking About Objects: Incorporating
Inheritance into the Elevator Simulation
Summary Terminology Self-Review Exercises Answers to Self-Review Exercises Exercises

9.1 Introduction
In this chapter, we begin our discussion of object-oriented programming (OOP) by intro-
ducing one of its main featuresinheritance. Inheritance is a form of software reusability
in which programmers create classes that absorb an existing classs data and behaviors and
enhance them with new capabilities. Software reusability saves time during program devel-
opment. It also encourages the reuse of proven and debugged high-quality software, which
increases the likelihood that a system will be implemented effectively.
When creating a class, instead of writing completely new data members and member
functions, the programmer can designate that the new class should inherit the members of
an existing class. This existing class is called the base class, and the new class is referred
to as the derived class. (Other programming languages, such as Java, refer to the base
class as the superclass and the derived class as the subclass.) A derived class represents a
more specialized group of objects. Typically, a derived class contains behaviors inherited
from its base class plus additional behaviors. As we will see, a derived class can also cus-
tomize behaviors inherited from the base class. A direct base class is the base class from
which a derived class explicitly inherits. An indirect base class is inherited from two or
more levels up the class hierarchy. In the case of single inheritance, a class is derived from
one base class. C++ also supports multiple inheritance, in which a derived class inherits
from multiple (possibly unrelated) base classes. Single inheritance is straightforwardwe
show several examples that should enable the reader to become proficient quickly. Multiple
inheritance can be complex and error prone. We cover multiple inheritance in Chapter 22.
C++ offers three kinds of inheritancepublic, protected and private. In this
chapter, we concentrate on public inheritance and briefly explain the other two kinds. In
Chapter 17, we show how private inheritance can be used as an alternative to composi-
tion. The third form, protected inheritance, is rarely used. With public inheritance,
every object of a derived class is also an object of that derived classs base class. However,
base-class objects are not objects of their derived classes. For example, all cars are vehicles,
Chapter 9 Object-Oriented Programming: Inheritance 611

but not all vehicles are cars. As we continue our study of object-oriented programming in
Chapter 9 and Chapter 10, we take advantage of this relationship to perform some inter-
esting manipulations.
Experience in building software systems indicates that significant portions of code
deal with closely related special cases. When programmers are preoccupied with special
cases, the details can obscure the big picture. With object-oriented programming, pro-
grammers focus on the commonalities among objects in the system, rather than on the spe-
cial cases. This process is called abstraction.
We distinguish between the is-a relationship and the has-a relationship. The is-
a relationship represents inheritance. In an is-a relationship, an object of a derived class
also can be treated as an object of its base classfor example, a car is a vehicle, so any
properties and behaviors of a vechicle are also properties of a car. By contrast, the has-a
relationship stands for composition. (Composition was discussed in Chapter 7.) In a has-
a relationship, an object contains one or more objects of other classes as membersfor
example, a car has a steering wheel.
Derived-class member functions might require access to base-class data members and
member functions. A derived class can access the non-private members of its base class.
Base-class members that should not be accessible to the member functions of derived
classes should be declared private in the base class. A derived class can effect state
changes in private base-class members, but only through non-private member func-
tions provided in the base class and inherited into the derived class.
Software Engineering Observation 9.1
Member functions of a derived class cannot directly access private members of their
classs base class. 9.1

Software Engineering Observation 9.2

If a derived class could access its base classs private members, classes that inherit from
that derived class could access that data as well. This would propagate access to what should
be private data, and the benefits of information hiding would be lost. 9.2

One problem with inheritance is that a derived class can inherit data members and
member functions it does not need or should not have. It is the class designers responsi-
bility to ensure that the capabilities provided by a class are appropriate for future derived
classes. Even when a base-class member function is appropriate for a derived class, the
derived class often requires that member function to behave in a manner specific to the
derived class. In such cases, the base-class member function can be redefined in the derived
class with an appropriate implementation.

9.2 Base Classes and Derived Classes

Often, an object of one class is an object of another class, as well. For example, in geom-
etry, a rectangle is a quadrilateral (as are squares, parallelograms and trapezoids). Thus, in
C++, class Rectangle can be said to inherit from class Quadrilateral. In this con-
text, class Quadrilateral is a base class, and class Rectangle is a derived class. A
rectangle is a specific type of quadrilateral, but it is incorrect to claim that a quadrilateral
is a rectanglethe quadrilateral could be a parallelogram or some other shape. Figure 9.1
lists several simple examples of base classes and derived classes.
612 Object-Oriented Programming: Inheritance Chapter 9

Base class Derived classes

Student GraduateStudent
UndergraduateStudent

Shape Circle
Triangle
Rectangle

Loan CarLoan
HomeImprovementLoan
MortgageLoan

Employee Faculty
Staff

Account CheckingAccount
SavingsAccount

Fig. 9.1 Inheritance examples.

Because every derived-class object is an object of its base class, and one base class
can have many derived classes, the set of objects represented by a base class typically is
larger than the set of objects represented by any of its derived classes. For example, the base
class Vehicle represents all vehicles, including cars, trucks, boats, bicycles and so on. By
contrast, derived class Car represents a smaller, more-specific subset of all vehicles.
Inheritance relationships form tree-like hierarchical structures. A base class exists in a
hierarchical relationship with its derived classes. Although classes can exist independently,
once they are employed in inheritance relationships, they become affiliated with other
classes. A class becomes either a base class, supplying data and behaviors to other classes,
or a derived class, inheriting its data and behaviors from other classes.
Let us develop a simple inheritance hierarchy. A university community has thousands
of members. These members consist of employees, students and alumni. Employees are
either faculty members or staff members. Faculty members are either administrators (such
as deans and department chairpersons) or teachers. This organizational structure yields the
inheritance hierarchy depicted in Fig. 9.2. Note that this inheritance hierarchy could con-
tain many other classes. For example, students can be graduate or undergraduate students.
Undergraduate students can be freshmen, sophomores, juniors and seniors. Each arrow in
the hierarchy represents an is-a relationship. For example, as we follow the arrows in this
class hierarchy, we can state an Employee is a CommunityMember and a Teacher
is a Faculty member. CommunityMember is the direct base class of Employee,
Student and Alumnus. In addition, CommunityMember is an indirect base class of
all the other classes in the diagram. Starting from the bottom of the diagram, the reader can
follow the arrows and apply the is-a relationship to the topmost base class. For example, an
Administrator is a Faculty member, is an Employee and is a Community-
Member. Note that some administrators also teach classes, so we have used multiple inher-
itance to form class AdministratorTeacher.
Chapter 9 Object-Oriented Programming: Inheritance 613

CommunityMember

Single
Employee Student Alumnus
inheritance

Single
Faculty Staff
inheritance

Single
Administrator Teacher
inheritance

Multiple
AdministratorTeacher
inheritance

Fig. 9.2 Inheritance hierarchy for university CommunityMembers.

Another inheritance hierarchy is the Shape hierarchy of Fig. 9.3. To specify that class
TwoDimensionalShape is derived from (or inherits from) class Shape, class
TwoDimensionalShape could be defined in C++ as follows:

class TwoDimensionalShape : public Shape

This is an example of public inheritance and is the most commonly used type of inher-
itance. We also will discuss private inheritance and protected inheritance
(Section 9.8). With public inheritance, private members of a base class are not acces-
sible directly from that classs derived classes, but these private base-class members are
still inherited. All other base-class members retain their original member access when they
become members of the derived class (e.g., public members of the base class become
public members of the derived class, and, as we will soon see, protected members
of the base class become protected members of the derived class). Through these in-
herited base-class members, the derived class can manipulate private members of the
base class (if these inherited members provide such functionality in the base class). Note
that friend functions are not inherited.
Inheritance is not appropriate for every class relationship. In Chapter 7, we discussed
the has-a relationship, in which classes have members that are objects of other classes.
Such relationships create classes by composition of existing classes. For example, given the
classes Employee, BirthDate and TelephoneNumber, it is improper to say that an
Employee is a BirthDate or that an Employee is a TelephoneNumber. However,
it is appropriate to say that an Employee has a BirthDate and that an Employee has
a TelephoneNumber.
It is possible to treat base-class objects and derived-class objects similarly; their com-
monalities are expressed in the members of the base class. Objects of all classes derived
from a common base class can be treated as objects of that base class (i.e., such objects have
614 Object-Oriented Programming: Inheritance Chapter 9

Shape

TwoDimensionalShape ThreeDimensionalShape

Circle Square Triangle Sphere Cube Tetrahedron

Fig. 9.3 Inheritance hierarchy for Shapes.

an is-a relationship with the base class). In Chapter 10, Object-Oriented Programming:
Polymorphism, we consider many examples that take advantage of this relationship.

9.3 protected Members

Chapter 7 discussed public and private member-access specifiers. A base classs
public members are accessible anywhere that the program has a handle (i.e., a name, ref-
erence or pointer) to an object of that base class or one of its derived classes. A base classs
private members are accessible only within the body of that base class and the
friends of that base class. In this section, we introduce an additional member-access
specifier: protected.
Using protected access offers an intermediate level of protection between
public and private access. A base classs protected members can be accessed by
members and friends of that base class and by members and friends of any classes
derived from that base class.
Derived-class member functions can refer to public and protected members of
the base class simply by using the member names. When a derived-class member function
redefines a base-class member function, the base-class member can be accessed from the
derived class by preceding the base-class member name with the base-class name and the
binary scope resolution operator (::). We discuss accessing redefined members of the base
class in Section 9.4.

9.4 Relationship between Base Classes and Derived Classes

In this section, we use a point/circle inheritance hierarchy1 to discuss the relationship be-
tween a base class and a derived class. We divide our discussion of the point/circle relation-
ship into several parts. First, we create class Point, which contains as private data an
xy coordinate pair. Then, we create class Circle, which contains as private data an
xy coordinate pair (representing the location of the center of the circle) and a radius. We

1. The point/circle relationship may seem unnatural when we say that a circle is a point. This ex-
ample teaches what is sometimes called structural inheritance and focuses on the mechanics of
inheritance and how a base class and a derived class relate to one another. In the exercises and in
Chapter 10, we present more natural inheritance examples.
 Chapter 9 Object-Oriented Programming: Inheritance 615

do not use inheritance to create class Circle; rather, we construct the class by writing ev-
ery line of code the class requires. Next, we create a separate Circle2 class, which inher-
its directly from class Point (i.e., class Circle2 is a Point but also contains a
radius) and attempts to access class Points private membersthis results in compi-
lation errors, because the derived class does not have access to the base classs private
data. We then show that if Points data is declared as protected, a Circle3 class
that inherits from class Point2 can access that data. For this purpose, we define class
Point2 with protected data. Both the inherited and noninherited Circle classes
contain identical functionality, but we show how the inherited Circle3 class is easier to
create and manage. After discussing the convenience of using protected data, we set the
Point data back to private in class Point3 (to enforce good software engineering),
then show how a separate Circle4 class (which inherits from class Point3) can use
Point3 member functions to manipulate Point3s private data.

Creating a Point Class

Let us first examine Points class definition (Fig. 9.4Fig. 9.5). The Point header file
(Fig. 9.4) specifies class Points public services, which include a constructor (line 9)
and member functions setX and getX (lines 1112), setY and getY (lines 1415) and
print (line 17). The Point header file specifies data members x and y as private
(lines 2021), so objects of other classes cannot access x and y directly. Technically, even
if Points data members x and y were made public, Point could never maintain an
invalid statea Point objects x and y data members could never contain invalid values,
because the xy coordinate plane is infinite in both directions. In general, however, declar-

1 // Fig. 9.4: point.h

2 // Point class definition represents an x-y coordinate pair.
3 #ifndef POINT_H
4 #define POINT_H
5
6 class Point {
7
8 public:
9 Point( int = 0, int = 0 ); // default constructor
10
11 void setX( int ); // set x in coordinate pair
12 int getX() const; // return x from coordinate pair
13
14 void setY( int ); // set y in coordinate pair
15 int getY() const; // return y from coordinate pair
16
17 void print() const; // output Point object
18
19 private:
20 int x; // x part of coordinate pair
21 int y; // y part of coordinate pair
22
23 }; // end class Point
24
25 #endif

Fig. 9.4 Point class header file.

 616 Object-Oriented Programming: Inheritance Chapter 9

ing data members as private and providing non-private member functions to manip-
ulate and validate the data members enforces good software engineering. [Note: The
Point constructor definition purposely does not use member-initializer syntax in the first
several examples of this section, so that we can demonstrate how private and pro-
tected specifiers affect member access in derived classes. As shown in Fig. 9.5, lines 12
13, we assign values to the data members in the constructor body. Later in this section, we
will return to using member-initializer lists in the constructors.]

1 // Fig. 9.5: point.cpp

2 // Point class member-function definitions.
3 #include <iostream>
4
5 using std::cout;
6
7 #include "point.h" // Point class definition
8
9 // default constructor
10 Point::Point( int xValue, int yValue )
11 {
12 x = xValue;
13 y = yValue;
14
15 } // end Point constructor
16
17 // set x in coordinate pair
18 void Point::setX( int xValue )
19 {
20 x = xValue; // no need for validation
21
22 } // end function setX
23
24 // return x from coordinate pair
25 int Point::getX() const
26 {
27 return x;
28
29 } // end function getX
30
31 // set y in coordinate pair
32 void Point::setY( int yValue )
33 {
34 y = yValue; // no need for validation
35
36 } // end function setY
37
38 // return y from coordinate pair
39 int Point::getY() const
40 {
41 return y;
42
43 } // end function getY
44

Fig. 9.5 Point class represents an xy coordinate pair. (Part 1 of 2.)

 Chapter 9 Object-Oriented Programming: Inheritance 617

45 // output Point object

46 void Point::print() const
47 {
48 cout << '[' << x << ", " << y << ']';
49
50 } // end function print

Fig. 9.5 Point class represents an xy coordinate pair. (Part 2 of 2.)

Figure 9.6 tests class Point. Line 12 instantiates object point of class Point and
passes 72 as the x-coordinate value and 115 as the y-coordinate value to the constructor.
Lines 1516 use points getX and getY member functions to retrieve these values, then
output the values. Lines 1819 invoke points member functions setX and setY to
change the values for points x and y data members. Line 23 then calls points print
member function to display the new x- and y-coordinate values.

1 // Fig. 9.6: pointtest.cpp

2 // Testing class Point.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 #include "point.h" // Point class definition
9
10 int main()
11 {
12 Point point( 72, 115 ); // instantiate Point object
13
14 // display point coordinates
15 cout << "X coordinate is " << point.getX()
16 << "\nY coordinate is " << point.getY() ;
17
18 point.setX( 10 ); // set x-coordinate
19 point.setY( 10 ); // set y-coordinate
20
21 // display new point value
22 cout << "\n\nThe new location of point is ";
23 point.print();
24 cout << endl;
25
26 return 0; // indicates successful termination
27
28 } // end main

X coordinate is 72
Y coordinate is 115

The new location of point is [10, 10]

Fig. 9.6 Point class test program.

 618 Object-Oriented Programming: Inheritance Chapter 9

Creating a Circle Class Without Using Inheritance

We now discuss the second part of our introduction to inheritance by creating and testing
(a completely new) class Circle (Fig. 9.7Fig. 9.8), which contains an xy coordinate
pair (indicating the center of the circle) and a radius. The Circle header file (Fig. 9.7)
specifies class Circles public services, which include the Circle constructor (line
11), member functions setX and getX (lines 1314), setY and getY (lines 1617),
setRadius and getRadius (lines 1920), getDiameter (line 22), getCircum-
ference (line 23), getArea (line 24) and print (line 26). Lines 2931 declare mem-
bers x, y and radius as private data. These data members and member functions
encapsulate all necessary features of a circle. In Section 9.5, we show how this encapsula-
tion enables us to reuse and extend this class.
Figure 9.9 tests class Circle. Line 17 instantiates object circle of class Circle,
passing 37 as the x-coordinate value, 43 as the y-coordinate value and 2.5 as the radius
value to the constructor. Lines 2022 use member functions getX, getY and getRadius

1 // Fig. 9.7: circle.h

2 // Circle class contains x-y coordinate pair and radius.
3 #ifndef CIRCLE_H
4 #define CIRCLE_H
5
6 class Circle {
7
8 public:
9
10 // default constructor
11 Circle( int = 0, int = 0, double = 0.0 );
12
13 void setX( int ); // set x in coordinate pair
14 int getX() const; // return x from coordinate pair
15
16 void setY( int ); // set y in coordinate pair
17 int getY() const; // return y from coordinate pair
18
19 void setRadius( double ); // set radius
20 double getRadius() const; // return radius
21
22 double getDiameter() const; // return diameter
23 double getCircumference() const; // return circumference
24 double getArea() const; // return area
25
26 void print() const; // output Circle object
27
28 private:
29 int x; // x-coordinate of Circle's center
30 int y; // y-coordinate of Circle's center
31 double radius; // Circle's radius
32
33 }; // end class Circle
34
35 #endif

Fig. 9.7 Circle class header file.

 Chapter 9 Object-Oriented Programming: Inheritance 619

1 // Fig. 9.8: circle.cpp

2 // Circle class member-function definitions.
3 #include <iostream>
4
5 using std::cout;
6
7 #include "circle.h" // Circle class definition
8
9 // default constructor
10 Circle::Circle( int xValue, int yValue, double radiusValue )
11 {
12 x = xValue;
13 y = yValue;
14 setRadius( radiusValue );
15
16 } // end Circle constructor
17
18 // set x in coordinate pair
19 void Circle::setX( int xValue )
20 {
21 x = xValue; // no need for validation
22
23 } // end function setX
24
25 // return x from coordinate pair
26 int Circle::getX() const
27 {
28 return x;
29
30 } // end function getX
31
32 // set y in coordinate pair
33 void Circle::setY( int yValue )
34 {
35 y = yValue; // no need for validation
36
37 } // end function setY
38
39 // return y from coordinate pair
40 int Circle::getY() const
41 {
42 return y;
43
44 } // end function getY
45
46 // set radius
47 void Circle::setRadius( double radiusValue )
48 {
49 radius = ( radiusValue < 0.0 ? 0.0 : radiusValue );
50
51 } // end function setRadius
52

Fig. 9.8 Circle class contains an xy coordinate and a radius. (Part 1 of 2.)
 620 Object-Oriented Programming: Inheritance Chapter 9

53 // return radius
54 double Circle::getRadius() const
55 {
56 return radius;
57
58 } // end function getRadius
59
60 // calculate and return diameter
61 double Circle::getDiameter() const
62 {
63 return 2 * radius;
64
65 } // end function getDiameter
66
67 // calculate and return circumference
68 double Circle::getCircumference() const
69 {
70 return 3.14159 * getDiameter();
71
72 } // end function getCircumference
73
74 // calculate and return area
75 double Circle::getArea() const
76 {
77 return 3.14159 * radius * radius;
78
79 } // end function getArea
80
81 // output Circle object
82 void Circle::print() const
83 {
84 cout << "Center = [" << x << ", " << y << ']'
85 << "; Radius = " << radius;
86
87 } // end function print

Fig. 9.8 Circle class contains an xy coordinate and a radius. (Part 2 of 2.)

to retrieve circles values, then display. Lines 2426 invoke circles setX, setY
and setRadius member functions to change the xy coordinates and the radius, respec-
tively. Member function setRadius (Fig. 9.8, lines 4751) ensures that data member
radius cannot be assigned a negative value (i.e., a circle cannot have a negative radius).
Line 30 of Fig. 9.9 calls circles print member function to display its x-coordinate, y-
coordinate and radius. Lines 3642 call circles getDiameter, getCircumfer-
ence and getArea member functions to display circles diameter, circumference and
area, respectively.
For class Circle (Fig. 9.7Fig. 9.8), note that much of the code is similar, if not iden-
tical, to the code in class Point (Fig. 9.4Fig. 9.5). For example, the declaration in class
Circle of private data members x and y and member functions setX, getX, setY
and getY are identical to those of class Point. In addition, the Circle constructor and
member function print are almost identical to those of class Point, except that they also
 Chapter 9 Object-Oriented Programming: Inheritance 621

manipulate the radius. The other additions to class Circle are private data member
radius and member functions setRadius, getRadius, getDiameter, get-
Circumference and getArea.

1 // Fig. 9.9: circletest.cpp

2 // Testing class Circle.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7 using std::fixed;
8
9 #include <iomanip>
10
11 using std::setprecision;
12
13 #include "circle.h" // Circle class definition
14
15 int main()
16 {
17 Circle circle( 37, 43, 2.5 ); // instantiate Circle object
18
19 // display point coordinates
20 cout << "X coordinate is " << circle.getX()
21 << "\nY coordinate is " << circle.getY()
22 << "\nRadius is " << circle.getRadius();
23
24 circle.setX( 2 ); // set new x-coordinate
25 circle.setY( 2 ); // set new y-coordinate
26 circle.setRadius( 4.25 ); // set new radius
27
28 // display new point value
29 cout << "\n\nThe new location and radius of circle are\n";
30 circle.print();
31
32 // display floating-point values with 2 digits of precision
33 cout << fixed << setprecision( 2 );
34
35 // display Circle's diameter
36 cout << "\nDiameter is " << circle.getDiameter();
37
38 // display Circle's circumference
39 cout << "\nCircumference is " << circle.getCircumference();
40
41 // display Circle's area
42 cout << "\nArea is " << circle.getArea();
43
44 cout << endl;
45
46 return 0; // indicates successful termination
47
48 } // end main

Fig. 9.9 Circle class test program. (Part 1 of 2.)

 622 Object-Oriented Programming: Inheritance Chapter 9

X coordinate is 37
Y coordinate is 43
Radius is 2.5
The new location and radius of circle are
Center = [2, 2]; Radius = 4.25
Diameter is 8.50
Circumference is 26.70
Area is 56.74

Fig. 9.9 Circle class test program. (Part 2 of 2.)

It appears that we literally copied code from class Point, pasted this code into class
Circle, then modified class Circle to include a radius and member functions that
manipulate the radius. This copy-and-paste approach is often error prone and time con-
suming. Worse yet, it can result in many physical copies of the code existing throughout a
system, creating a code-maintenance nightmare. Is there a way to absorb the attributes
and behaviors of one class in a way that makes them part of other classes without dupli-
cating code? In the next several examples, we answer that question using a more elegant
class construction approach emphasizing the benefits of inheritance.

Point/Circle Hierarchy Using Inheritance

Now we create and test class Circle2 (Fig. 9.10Fig. 9.11), which inherits data members
x and y and member functions setX, getX, setY and getY from class Point
(Fig. 9.4Fig. 9.5). An object of class Circle2 is a Point (because inheritance ab-
sorbs the capabilities of class Point), but, as evidenced by the class Circle2 header file,
also contains data member radius (Fig. 9.10, line 25). The colon (:) in line 8 of the class
definition indicates inheritance. Keyword public indicates the type of inheritance. As a
derived class (formed with public inheritance), Circle2 inherits all the members of
class Point, except for the constructor. Thus, the public services of Circle2 include the
Circle2 constructor (line 13)each class provides its own constructors that are specific
to the classthe public member functions inherited from class Point; member func-
tions setRadius and getRadius (lines 1516); and member functions getDiame-
ter, getCircumference, getArea and print (lines 1822).

1 // Fig. 9.10: circle2.h

2 // Circle2 class contains x-y coordinate pair and radius.
3 #ifndef CIRCLE2_H
4 #define CIRCLE2_H
5
6 #include "point.h" // Point class definition
7
8 class Circle2 : public Point {
9
10 public:
11
12 // default constructor
13 Circle2( int = 0, int = 0, double = 0.0 );

Fig. 9.10 Circle2 class header file. (Part 1 of 2.)

 Chapter 9 Object-Oriented Programming: Inheritance 623

14
15 void setRadius( double ); // set radius
16 double getRadius() const; // return radius
17
18 double getDiameter() const; // return diameter
19 double getCircumference() const; // return circumference
20 double getArea() const; // return area
21
22 void print() const; // output Circle2 object
23
24 private:
25 double radius; // Circle2's radius
26
27 }; // end class Circle2
28
29 #endif

Fig. 9.10 Circle2 class header file. (Part 2 of 2.)

Figure 9.11 shows the member-function implementations for class Circle2. The
constructor (lines 1016) should set the xy coordinate to a specific value, so lines 1213
attempt to assign parameter values to x and y directly. The compiler generates syntax errors
for lines 12 and 13 (and line 56, where Circle2s print member function attempts to
use the values of x and y directly), because the derived class Circle2 is not allowed to
access base class Points private data members x and y. As you can see, C++ rigidly
enforces restrictions on accessing private data members, so that even a derived class
(which is closely related to its base class) cannot access the base classs private data.

1 // Fig. 9.11: circle2.cpp

2 // Circle2 class member-function definitions.
3 #include <iostream>
4
5 using std::cout;
6
7 #include "circle2.h" // Circle2 class definition
8
9 // default constructor
10 Circle2::Circle2( int xValue, int yValue, double radiusValue )
11 {
12 x = xValue;
13 y = yValue;
14 setRadius( radiusValue );
15
16 } // end Circle2 constructor
17
18 // set radius
19 void Circle2::setRadius( double radiusValue )
20 {
21 radius = ( radiusValue < 0.0 ? 0.0 : radiusValue );
22
23 } // end function setRadius

Fig. 9.11 Private base-class data cannot be accessed from derived class. (Part 1 of 3.)
 624 Object-Oriented Programming: Inheritance Chapter 9

24
25 // return radius
26 double Circle2::getRadius() const
27 {
28 return radius;
29
30 } // end function getRadius
31
32 // calculate and return diameter
33 double Circle2::getDiameter() const
34 {
35 return 2 * radius;
36
37 } // end function getDiameter
38
39 // calculate and return circumference
40 double Circle2::getCircumference() const
41 {
42 return 3.14159 * getDiameter();
43
44 } // end function getCircumference
45
46 // calculate and return area
47 double Circle2::getArea() const
48 {
49 return 3.14159 * radius * radius;
50
51 } // end function getArea
52
53 // output Circle2 object
54 void Circle2::print() const
55 {
56 cout << "Center = [" << x << ", " << y << ']'
57 << "; Radius = " << radius;
58
59 } // end function print

C:\cpphtp4\examples\ch09\CircleTest\circle2.cpp(12) : error C2248:

'x' : cannot access private member declared in class 'Point'
C:\cpphtp4\examples\ch09\circletest\point.h(20) :
see declaration of 'x'

C:\cpphtp4\examples\ch09\CircleTest\circle2.cpp(13) : error C2248:

'y' : cannot access private member declared in class 'Point'
C:\cpphtp4\examples\ch09\circletest\point.h(21) :
see declaration of 'y'

C:\cpphtp4\examples\ch09\CircleTest\circle2.cpp(56) : error C2248:

'x' : cannot access private member declared in class 'Point'
C:\cpphtp4\examples\ch09\circletest\point.h(20) :
see declaration of 'x'
(continued next page)

Fig. 9.11 Private base-class data cannot be accessed from derived class. (Part 2 of 3.)
 Chapter 9 Object-Oriented Programming: Inheritance 625

C:\cpphtp4\examples\ch09\CircleTest\circle2.cpp(56) : error C2248:

'y' : cannot access private member declared in class 'Point'
C:\cpphtp4\examples\ch09\circletest\point.h(21) :
see declaration of 'y'

Fig. 9.11 Private base-class data cannot be accessed from derived class. (Part 3 of 3.)

Point/Circle Hierarchy Using protected Data

To enable class Circle2 to access Point data members x and y directly, we can declare
those members as protected in the base class. As we discussed in Section 9.3, a base
classs protected members can be accessed by members and friends of the base class
and by members and friends of any classes derived from that base class. Class Point2
(Fig. 9.12Fig. 9.13) is a modification of class Point (Fig. 9.4Fig. 9.5) that declares data
members x and y as protected (Fig. 9.12, lines 1921) rather than private. Other
than the class name change (and, hence, the constructor name change) to Point2, the
member-function implementations in Fig. 9.13 are identical to those in Fig. 9.5.

1 // Fig. 9.12: point2.h

2 // Point2 class definition represents an x-y coordinate pair.
3 #ifndef POINT2_H
4 #define POINT2_H
5
6 class Point2 {
7
8 public:
9 Point2( int = 0, int = 0 ); // default constructor
10
11 void setX( int ); // set x in coordinate pair
12 int getX() const; // return x from coordinate pair
13
14 void setY( int ); // set y in coordinate pair
15 int getY() const; // return y from coordinate pair
16
17 void print() const; // output Point2 object
18
19 protected:
20 int x; // x part of coordinate pair
21 int y; // y part of coordinate pair
22
23 }; // end class Point2
24
25 #endif

Fig. 9.12 Point2 class header file.

1 // Fig. 9.13: point2.cpp

2 // Point2 class member-function definitions.
3 #include <iostream>

Fig. 9.13 Point2 class represents an xy coordinate pair as protected data.

(Part 1 of 2.)
 626 Object-Oriented Programming: Inheritance Chapter 9

4
5 using std::cout;
6
7 #include "point2.h" // Point2 class definition
8
9 // default constructor
10 Point2::Point2( int xValue, int yValue )
11 {
12 x = xValue;
13 y = yValue;
14
15 } // end Point2 constructor
16
17 // set x in coordinate pair
18 void Point2::setX( int xValue )
19 {
20 x = xValue; // no need for validation
21
22 } // end function setX
23
24 // return x from coordinate pair
25 int Point2::getX() const
26 {
27 return x;
28
29 } // end function getX
30
31 // set y in coordinate pair
32 void Point2::setY( int yValue )
33 {
34 y = yValue; // no need for validation
35
36 } // end function setY
37
38 // return y from coordinate pair
39 int Point2::getY() const
40 {
41 return y;
42
43 } // end function getY
44
45 // output Point2 object
46 void Point2::print() const
47 {
48 cout << '[' << x << ", " << y << ']';
49
50 } // end function print

Fig. 9.13 Point2 class represents an xy coordinate pair as protected data.

(Part 2 of 2.)

Class Circle3 (Fig. 9.14Fig. 9.15) is a modification of class Circle2 (Fig. 9.10
Fig. 9.11) that inherits from class Point2 rather than from class Point. Because class
Circle3 inherits from class Point2, objects of class Circle3 can access inherited
 Chapter 9 Object-Oriented Programming: Inheritance 627

data members that were declared protected in class Point2 (i.e., data members x and
y). As a result, the compiler does not generate errors when compiling the Circle3 con-
structor and print member function definitions in Fig. 9.15 (lines 1016 and 5459,
respectively). This shows the special privileges that a derived class is granted to access
protected base-class data members. Objects of a derived class also can access pro-
tected members in any of that derived classs indirect base classes.

1 // Fig. 9.14: circle3.h

2 // Circle3 class contains x-y coordinate pair and radius.
3 #ifndef CIRCLE3_H
4 #define CIRCLE3_H
5
6 #include "point2.h" // Point2 class definition
7
8 class Circle3 : public Point2 {
9
10 public:
11
12 // default constructor
13 Circle3( int = 0, int = 0, double = 0.0 );
14
15 void setRadius( double ); // set radius
16 double getRadius() const; // return radius
17
18 double getDiameter() const; // return diameter
19 double getCircumference() const; // return circumference
20 double getArea() const; // return area
21
22 void print() const; // output Circle3 object
23
24 private:
25 double radius; // Circle3's radius
26
27 }; // end class Circle3
28
29 #endif

Fig. 9.14 Circle3 class header file.

1 // Fig. 9.15: circle3.cpp

2 // Circle3 class member-function definitions.
3 #include <iostream>
4
5 using std::cout;
6
7 #include "circle3.h" // Circle3 class definition
8
9 // default constructor
10 Circle3::Circle3( int xValue, int yValue, double radiusValue )
11 {
12 x = xValue;

Fig. 9.15 Circle3 class that inherits from class Point2. (Part 1 of 2.)
 628 Object-Oriented Programming: Inheritance Chapter 9

13 y = yValue;
14 setRadius( radiusValue );
15
16 } // end Circle3 constructor
17
18 // set radius
19 void Circle3::setRadius( double radiusValue )
20 {
21 radius = ( radiusValue < 0.0 ? 0.0 : radiusValue );
22
23 } // end function setRadius
24
25 // return radius
26 double Circle3::getRadius() const
27 {
28 return radius;
29
30 } // end function getRadius
31
32 // calculate and return diameter
33 double Circle3::getDiameter() const
34 {
35 return 2 * radius;
36
37 } // end function getDiameter
38
39 // calculate and return circumference
40 double Circle3::getCircumference() const
41 {
42 return 3.14159 * getDiameter();
43
44 } // end function getCircumference
45
46 // calculate and return area
47 double Circle3::getArea() const
48 {
49 return 3.14159 * radius * radius;
50
51 } // end function getArea
52
53 // output Circle3 object
54 void Circle3::print() const
55 {
56 cout << "Center = [" << x << ", " << y << ']'
57 << "; Radius = " << radius;
58
59 } // end function print

Fig. 9.15 Circle3 class that inherits from class Point2. (Part 2 of 2.)

Class Circle3 does not inherit class Point2s constructor. However, class
Circle3s constructor (lines 1016) calls class Point2s constructor implicitly. In fact,
the first task of any derived-class constructor is to call its direct base classs constructor,
either implicitly or explicitly. (The syntax for calling a base-class constructor is discussed
 Chapter 9 Object-Oriented Programming: Inheritance 629

later in this section.) If the code does not include an explicit call to the base-class con-
structor, an implicit call is made to the base classs default constructor. Even though lines
1213 set x and y values explicitly, the constructor first calls the Point2 default con-
structor, which initializes these data members to their default 0 values. Thus, x and y each
are initialized twice. We will fix this performance problem in the next examples.
Figure 9.16 performs identical tests on class Circle3 as those that Fig. 9.9 performed
on class Circle (Fig. 9.7Fig. 9.8). Note that the outputs of the two programs are identical.
We created class Circle without using inheritance and created class Circle3 using
inheritance; however, both classes provide the same functionality. Note that the code listing
for class Circle3 (i.e., the header and implementation files), which is 88 lines, is consid-
erably shorter than the code listing for class Circle, which is 122 lines, because class
Circle3 absorbs part of its functionality from Point2, whereas class Circle does not
absorb any functionality. Also, there is now only one copy of the point functionality men-
tioned in class Point2. This makes the code easier to debug, maintain and modify, because
the point-related code exists only in the files of Fig. 9.12Fig. 9.13.

1 // Fig. 9.16: circletest3.cpp

2 // Testing class Circle3.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7 using std::fixed;
8
9 #include <iomanip>
10
11 using std::setprecision;
12
13 #include "circle3.h" // Circle3 class definition
14
15 int main()
16 {
17 Circle3 circle( 37, 43, 2.5 ); // instantiate Circle3 object
18
19 // display point coordinates
20 cout << "X coordinate is " << circle.getX()
21 << "\nY coordinate is " << circle.getY()
22 << "\nRadius is " << circle.getRadius();
23
24 circle.setX( 2 ); // set new x-coordinate
25 circle.setY( 2 ); // set new y-coordinate
26 circle.setRadius( 4.25 ); // set new radius
27
28 // display new point value
29 cout << "\n\nThe new location and radius of circle are\n";
30 circle.print();
31
32 // display floating-point values with 2 digits of precision
33 cout << fixed << setprecision( 2 );
34

Fig. 9.16 Protected base-class data can be accessed from derived class. (Part 1 of 2.)
 630 Object-Oriented Programming: Inheritance Chapter 9

35 // display Circle3's diameter

36 cout << "\nDiameter is " << circle.getDiameter();
37
38 // display Circle3's circumference
39 cout << "\nCircumference is " << circle.getCircumference();
40
41 // display Circle3's area
42 cout << "\nArea is " << circle.getArea();
43
44 cout << endl;
45
46 return 0; // indicates successful termination
47
48 } // end main

X coordinate is 37
Y coordinate is 43
Radius is 2.5

The new location and radius of circle are

Center = [2, 2]; Radius = 4.25
Diameter is 8.50
Circumference is 26.70
Area is 56.74

Fig. 9.16 Protected base-class data can be accessed from derived class. (Part 2 of 2.)

In this example, we declared base-class data members as protected, so that derived

classes could modify their values directly. The use of protected data members allows for
a slight increase in performance, because we avoid incurring the overhead of a call to a set or
get member function. However, such performance increases are often negligible compared to
the optimizations compilers can perform. It is better to use private data to encourage
proper software engineering. Your code will be easier to maintain, modify and debug.
Using protected data members creates two major problems. First, the derived-class
object does not have to use a member function to set the value of the base-classs pro-
tected data member. Therefore, a derived-class object easily can assign an illegal value
to the protected data member, thus leaving the object in an invalid state. For example,
if we were to declare Circle3s data member radius as protected, a derived-class
object (e.g., Cylinder) could then assign a negative value to radius. The second
problem with using protected data members is that derived-class member functions are
more likely to be written to depend on the base-class implementation. In practice, derived
classes should depend only on the base-class services (i.e., non-private member func-
tions) and not on the base-class implementation. With protected data members in the
base class, if the base-class implementation changes, we may need to modify all derived
classes of that base class. For example, if for some reason we were to change the names of
data members x and y to xCoordinate and yCoordinate, then we would have to do
so for all occurrences in which a derived class references these base-class data members
directly. In such a case, the software is said to be fragile or brittle, because a small change
in the base class can break derived-class implementation. The programmer should be
able to change the base-class implementation freely, while still providing the same services
 Chapter 9 Object-Oriented Programming: Inheritance 631

to derived classes. (Of course, if the base-class services change, we must reimplement our
derived classes, but good object-oriented design attempts to prevent this.)
Software Engineering Observation 9.3
It is appropriate to use the protected access specifier when a base class should provide
a service (i.e., a member function) only to its derived classes and should not provide the ser-
vice to other clients. 9.3

Software Engineering Observation 9.4

Declaring base-class data members private (as opposed to declaring them protected)
enables programmers to change the base-class implementation without having to change de-
rived-class implementations. 9.4

Testing and Debugging Tip 9.1

When possible, avoid including protected data members in a base class. Rather, include
non-private member functions that access private data members, ensuring that the ob-
ject maintains a consistent state. 9.1

Point/Circle Hierarchy Using private Data

We now reexamine our point/circle hierarchy example once more; this time, attempting to
use the best software-engineering practices. Class Point3 (Fig. 9.17Fig. 9.18) declares
data members x and y as private (Fig. 9.17, lines 1921) and exposes member functions
setX, getX, setY, getY and print for manipulating these values. In the constructor
implementation (Fig. 9.18, lines 1015), note that member initializers are used (line 11) to
specify the values of members x and y. We show how derived-class Circle4 (Fig. 9.19
Fig. 9.20) can invoke non-private base-class member functions (setX, getX, setY
and getY) to manipulate these data members.
Software Engineering Observation 9.5
When possible, use member functions to alter and obtain the values of data members, even if
those values can be modified directly. A set member function can prevent attempts to assign
inappropriate values to the data member, and a get member function can help control the
presentation of the data to clients. 9.5

Performance Tip 9.1

Using a member function to access a data members value can be slightly slower than ac-
cessing the data directly. However, attempting to optimize programs by referencing data di-
rectly often is unnecessary, because the compiler optimizes the programs implicitly. Todays
so-called optimizing compilers are carefully designed to perform many optimizations im-
plicitly, even if the programmer does not write what appears to be the most optimal code. A
good rule is, Do not second-guess the compiler. 9.1

1 // Fig. 9.17: point3.h

2 // Point3 class definition represents an x-y coordinate pair.
3 #ifndef POINT3_H
4 #define POINT3_H
5
6 class Point3 {
7

Fig. 9.17 Point3 class header file. (Part 1 of 2.)

 632 Object-Oriented Programming: Inheritance Chapter 9

8 public:
9 Point3( int = 0, int = 0 ); // default constructor
10
11 void setX( int ); // set x in coordinate pair
12 int getX() const; // return x from coordinate pair
13
14 void setY( int ); // set y in coordinate pair
15 int getY() const; // return y from coordinate pair
16
17 void print() const; // output Point3 object
18
19 private:
20 int x; // x part of coordinate pair
21 int y; // y part of coordinate pair
22
23 }; // end class Point3
24
25 #endif

Fig. 9.17 Point3 class header file. (Part 2 of 2.)

1 // Fig. 9.18: point3.cpp

2 // Point3 class member-function definitions.
3 #include <iostream>
4
5 using std::cout;
6
7 #include "point3.h" // Point3 class definition
8
9 // default constructor
10 Point3::Point3( int xValue, int yValue )
11 : x( xValue ), y( yValue )
12 {
13 // empty body
14
15 } // end Point3 constructor
16
17 // set x in coordinate pair
18 void Point3::setX( int xValue )
19 {
20 x = xValue; // no need for validation
21
22 } // end function setX
23
24 // return x from coordinate pair
25 int Point3::getX() const
26 {
27 return x;
28
29 } // end function getX
30

Fig. 9.18 Point3 class uses member functions to manipulate its private data.
(Part 1 of 2.)
 Chapter 9 Object-Oriented Programming: Inheritance 633

31 // set y in coordinate pair

32 void Point3::setY( int yValue )
33 {
34 y = yValue; // no need for validation
35
36 } // end function setY
37
38 // return y from coordinate pair
39 int Point3::getY() const
40 {
41 return y;
42
43 } // end function getY
44
45 // output Point3 object
46 void Point3::print() const
47 {
48 cout << '[' << getX() << ", " << getY() << ']';
49
50 } // end function print

Fig. 9.18 Point3 class uses member functions to manipulate its private data.
(Part 2 of 2.)

Class Circle4 (Fig. 9.19Fig. 9.20) has several changes to its member function
implementations (Fig. 9.20) that distinguish it from class Circle3 (Fig. 9.14Fig. 9.15).
Class Circle4s constructor (lines 1015) introduces base-class initializer syntax (line
11), which uses a member initializer to pass arguments to the base-class (Point3) con-
structor. C++ actually requires a derived-class constructor to call its base-class constructor
to initialize the base-class data members that are inherited into the derived class. Line 11
accomplishes this task by invoking the Point3 constructor by name. Values xValue and
yValue are passed from the Circle4 constructor to the Point3 constructor to initialize
base-class members x and y. If the Circle constructor did not invoke the Point con-
structor explicitly, the default Point constructor would be invoked implicitly with the
default values for x and y (i.e., 0 and 0). If class Point3 did not provide a default con-
structor, the compiler would issue a syntax error.
Common Programming Error 9.1
It is a syntax error if a derived-class constructor calls one of its base-class constructors with
arguments that do not match exactly the number and types of parameters specified in one of
the base-class constructor definitions. 9.1

In Fig. 9.15, class Circle3s constructor actually initialized base-class members x

and y twice. First, class Point2s constructor was called implicitly with the default values
x and y, then class Circle3s constructor assigned values to x and y in its body.

1 // Fig. 9.19: circle4.h

2 // Circle4 class contains x-y coordinate pair and radius.
3 #ifndef CIRCLE4_H
4 #define CIRCLE4_H

Fig. 9.19 Circle4 class header file. (Part 1 of 2.)

 634 Object-Oriented Programming: Inheritance Chapter 9

5
6 #include "point3.h" // Point3 class definition
7
8 class Circle4 : public Point3 {
9
10 public:
11
12 // default constructor
13 Circle4( int = 0, int = 0, double = 0.0 );
14
15 void setRadius( double ); // set radius
16 double getRadius() const; // return radius
17
18 double getDiameter() const; // return diameter
19 double getCircumference() const; // return circumference
20 double getArea() const; // return area
21
22 void print() const; // output Circle4 object
23
24 private:
25 double radius; // Circle4's radius
26
27 }; // end class Circle4
28
29 #endif

Fig. 9.19 Circle4 class header file. (Part 2 of 2.)

1 // Fig. 9.20: circle4.cpp

2 // Circle4 class member-function definitions.
3 #include <iostream>
4
5 using std::cout;
6
7 #include "circle4.h" // Circle4 class definition
8
9 // default constructor
10 Circle4::Circle4( int xValue, int yValue, double radiusValue )
11 : Point3( xValue, yValue ) // call base-class constructor
12 {
13 setRadius( radiusValue );
14
15 } // end Circle4 constructor
16
17 // set radius
18 void Circle4::setRadius( double radiusValue )
19 {
20 radius = ( radiusValue < 0.0 ? 0.0 : radiusValue );
21
22 } // end function setRadius
23

Fig. 9.20 Circle4 class that inherits from class Point3, which does not provide
protected data. (Part 1 of 2.)
 Chapter 9 Object-Oriented Programming: Inheritance 635

24 // return radius
25 double Circle4::getRadius() const
26 {
27 return radius;
28
29 } // end function getRadius
30
31 // calculate and return diameter
32 double Circle4::getDiameter() const
33 {
34 return 2 * getRadius();
35
36 } // end function getDiameter
37
38 // calculate and return circumference
39 double Circle4::getCircumference() const
40 {
41 return 3.14159 * getDiameter();
42
43 } // end function getCircumference
44
45 // calculate and return area
46 double Circle4::getArea() const
47 {
48 return 3.14159 * getRadius() * getRadius();
49
50 } // end function getArea
51
52 // output Circle4 object
53 void Circle4::print() const
54 {
55 cout << "Center = ";
56 Point3::print(); // invoke Point3's print function
57 cout << "; Radius = " << getRadius();
58
59 } // end function print

Fig. 9.20 Circle4 class that inherits from class Point3, which does not provide
protected data. (Part 2 of 2.)
Performance Tip 9.2
In a derived-class constructor, initializing member objects and invoking base-class construc-
tors explicitly in the member initializer list can prevent duplicate initialization in which a de-
fault constructor is called, then data members are modified again in the body of the derived-
class constructor. 9.2

In addition to the changes discusses so far, member functions getDiameter

(Fig. 9.20, lines 3236), getArea (lines 4650) and print (lines 5359) each invoke
member function getRadius to obtain the radius value, rather than accessing the
radius directly. If we decide to rename data member radius, only the bodies of func-
tions setRadius and getRadius will need to change.
Class Circle4s print function (Fig. 9.20, lines 5359) redefines class Point3s
print member function (Fig. 9.18, lines 4650). Class Circle4s version displays the
 636 Object-Oriented Programming: Inheritance Chapter 9

private data members x and y of class Point3 by calling base-class Point3s print
function with the expression Point3::print() (line 56). Note the syntax used to invoke
a redefined base-class member function from a derived classplace the base-class name
and the binary scope-resolution operator (::) before the base-class member-function name.
This member-function invocation is a good software engineering practice: Recall that Soft-
ware Engineering Observation 6.19 stated that, if an objects member function performs the
actions needed by another object, call that member function rather than duplicating its code
body. By having Circle4s print function invoke Point3s print function to per-
form part of the task of printing a Circle4 object (i.e., to display the x- and y-coordinate
values), we avoid duplicating code and reduce code-maintenance problems.
Common Programming Error 9.2
When a base-class member function is redefined in a derived class, the derived-class version
often calls the base-class version to do additional work. Failure to use the :: reference (pre-
fixed with the name of the base class) when referencing the base classs member function
causes infinite recursion, because the derived-class member function would then call itself. 9.2

Common Programming Error 9.3

Including a base-class member function with a different signature in the derived class hides
the base-class version of the function. Attempts to call the base-class version through the
public interface of a derived-class object result in compilation errors. 9.3

Figure 9.21 performs identical manipulations on a Circle4 object as did Fig. 9.9 and
Fig. 9.16 on objects of classes Circle and Circle3, respectively. Although each circle
class behaves identically, class Circle4 is the best engineered. Using inheritance, we have
efficiently and effectively constructed a well-engineered class.

1 // Fig. 9.21: circletest4.cpp

2 // Testing class Circle4.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7 using std::fixed;
8
9 #include <iomanip>
10
11 using std::setprecision;
12
13 #include "circle4.h" // Circle4 class definition
14
15 int main()
16 {
17 Circle4 circle( 37, 43, 2.5 ); // instantiate Circle4 object
18
19 // display point coordinates
20 cout << "X coordinate is " << circle.getX()
21 << "\nY coordinate is " << circle.getY()
22 << "\nRadius is " << circle.getRadius();

Fig. 9.21 Base-class private data is accessible to a derived class via public or
protected member function inherited by the derived class. (Part 1 of 2.)
 Chapter 9 Object-Oriented Programming: Inheritance 637

23
24 circle.setX( 2 ); // set new x-coordinate
25 circle.setY( 2 ); // set new y-coordinate
26 circle.setRadius( 4.25 ); // set new radius
27
28 // display new circle value
29 cout << "\n\nThe new location and radius of circle are\n";
30 circle.print();
31
32 // display floating-point values with 2 digits of precision
33 cout << fixed << setprecision( 2 );
34
35 // display Circle4's diameter
36 cout << "\nDiameter is " << circle.getDiameter();
37
38 // display Circle4's circumference
39 cout << "\nCircumference is " << circle.getCircumference();
40
41 // display Circle4's area
42 cout << "\nArea is " << circle.getArea();
43
44 cout << endl;
45
46 return 0; // indicates successful termination
47
48 } // end main

X coordinate is 37
Y coordinate is 43
Radius is 2.5
The new location and radius of circle are
Center = [2, 2]; Radius = 4.25
Diameter is 8.50
Circumference is 26.70
Area is 56.74

Fig. 9.21 Base-class private data is accessible to a derived class via public or
protected member function inherited by the derived class. (Part 2 of 2.)

9.5 Case Study: Three-Level Inheritance Hierarchy

Let us consider a more substantial inheritance example involving a three-level point/circle
cylinder hierarchy. In Section 9.4, we developed classes Point3 (Fig. 9.17Fig. 9.18) and
Circle4 (Fig. 9.19Fig. 9.20). Now, we present an example in which we derive class
Cylinder from class Circle4.
The first class that we use in our case study is class Point3 (Fig. 9.17Fig. 9.18). We
declared Point3s data members as private. Class Point3 also contains member
functions setX, getX, setY and getY for accessing x and y, and member function
print for displaying the xy coordinate pair on the standard output.
We also use class Circle4 (Fig. 9.19Fig. 9.20), which inherits from class Point3.
Class Circle4 contains functionality from class Point3 and provides member function
setRadius, which ensures that the radius data member cannot hold a negative value,
 638 Object-Oriented Programming: Inheritance Chapter 9

and member functions getRadius, getDiameter, getCircumference, getArea

and print. Derived classes of class Circle4 (such as class Cylinder, which we intro-
duce momentarily) should redefine these member functions as necessary to provide imple-
mentations specific to the derived class. For example, a circle has an area that is calculated
by the formula, r2, in which r represents the circles radius. However, a cylinder has a sur-
face area that is calculated by the formula, (2r2) + (2rh), in which r represents the cyl-
inders radius and h represents the cylinders height. Therefore, class Cylinder should
redefine member function getArea to include this calculation.
Figure 9.22Fig. 9.23 present class Cylinder, which inherits from class Circle4.
The Cylinder header file (Fig. 9.22) specifies that a Cylinder has a height (line 23)
and specifies class Cylinders public services, which include inherited Circle4
member functions (line 8) setRadius, getRadius, getDiameter, getCircum-
ference, getArea and print; indirectly inherited Point3 member functions setX,
getX, setY and getY; the Cylinder constructor (line 13); and Cylinder member
functions setHeight, getHeight, getArea, getVolume and print (lines 1520).
Member functions getArea and print redefine the member functions with the same
names that are inherited from class Circle4.
Figure 9.23 shows class Cylinders member-function implementations. Member
function getArea (lines 3338) redefines member function getArea of class Circle4
to calculate surface area. Member function print (lines 4853) redefines member function
print of class Circle4 to display the text representation of the cylinder to the standard

1 // Fig. 9.22: cylinder.h

2 // Cylinder class inherits from class Circle4.
3 #ifndef CYLINDER_H
4 #define CYLINDER_H
5
6 #include "circle4.h" // Circle4 class definition
7
8 class Cylinder : public Circle4 {
9
10 public:
11
12 // default constructor
13 Cylinder( int = 0, int = 0, double = 0.0, double = 0.0 );
14
15 void setHeight( double ); // set Cylinder's height
16 double getHeight() const; // return Cylinder's height
17
18 double getArea() const; // return Cylinder's area
19 double getVolume() const; // return Cylinder's volume
20 void print() const; // output Cylinder
21
22 private:
23 double height; // Cylinder's height
24
25 }; // end class Cylinder
26
27 #endif

Fig. 9.22 Cylinder class header file.

 Chapter 9 Object-Oriented Programming: Inheritance 639

output. Class Cylinder also includes member function getVolume (lines 4145) to cal-
culate the cylinders volume.
Figure 9.24 is a CylinderTest application that tests class Cylinder. Line 18
instantiates a Cylinder object called cylinder. Lines 2124 use cylinders

1 // Fig. 9.23: cylinder.cpp

2 // Cylinder class inherits from class Circle4.
3 #include <iostream>
4
5 using std::cout;
6
7 #include "cylinder.h" // Cylinder class definition
8
9 // default constructor
10 Cylinder::Cylinder( int xValue, int yValue, double radiusValue,
11 double heightValue )
12 : Circle4( xValue, yValue, radiusValue )
13 {
14 setHeight( heightValue );
15
16 } // end Cylinder constructor
17
18 // set Cylinder's height
19 void Cylinder::setHeight( double heightValue )
20 {
21 height = ( heightValue < 0.0 ? 0.0 : heightValue );
22
23 } // end function setHeight
24
25 // get Cylinder's height
26 double Cylinder::getHeight() const
27 {
28 return height;
29
30 } // end function getHeight
31
32 // redefine Circle4 function getArea to calculate Cylinder area
33 double Cylinder::getArea() const
34 {
35 return 2 * Circle4::getArea() +
36 getCircumference() * getHeight();
37
38 } // end function getArea
39
40 // calculate Cylinder volume
41 double Cylinder::getVolume() const
42 {
43 return Circle4::getArea() * getHeight();
44
45 } // end function getVolume
46

Fig. 9.23 Cylinder class inherits from class Circle4 and redefines member
function getArea. (Part 1 of 2.)
 640 Object-Oriented Programming: Inheritance Chapter 9

47 // output Cylinder object

48 void Cylinder::print() const
49 {
50 Circle4::print();
51 cout << "; Height = " << getHeight();
52
53 } // end function print

Fig. 9.23 Cylinder class inherits from class Circle4 and redefines member
function getArea. (Part 2 of 2.)

member functions getX, getY, getRadius and getHeight to obtain information

about cylinder, because CylinderTest cannot reference the private data mem-
bers of class Cylinder directly. Lines 2629 use member functions setX, setY, set-
Radius and setHeight to reset cylinders xy coordinates (we assume the
cylinders xy coordinates specify the position of the center of its bottom on the xy plane),
radius and height. Class Cylinder can use class Point3s setX, getX, setY and
getY member functions, because class Cylinder inherits them indirectly from class
Point3. (Class Cylinder inherits member functions setX, getX, setY and getY
directly from class Circle4, which inherited them directly from class Point3.) Line 33
invokes cylinders print member function to display the text representation of object
cylinder. Lines 39 and 43 invoke member functions getDiameter and getCir-
cumference of the cylinder objectbecause class Cylinder inherits these func-
tions from class Circle4, these member functions, exactly as defined in Circle4, are
invoked. Lines 46 and 49 invoke member functions getArea and getVolume to deter-
mine the surface area and volume of cylinder.

1 // Fig. 9.24: cylindertest.cpp

2 // Testing class Cylinder.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7 using std::fixed;
8
9 #include <iomanip>
10
11 using std::setprecision;
12
13 #include "cylinder.h" // Cylinder class definition
14
15 int main()
16 {
17 // instantiate Cylinder object
18 Cylinder cylinder( 12, 23, 2.5, 5.7 );
19
20 // display point coordinates
21 cout << "X coordinate is " << cylinder.getX()
22 << "\nY coordinate is " << cylinder.getY()

Fig. 9.24 Point/Circle/Cylinder hierarchy test program. (Part 1 of 2.)

 Chapter 9 Object-Oriented Programming: Inheritance 641

23 << "\nRadius is " << cylinder.getRadius()

24 << "\nHeight is " << cylinder.getHeight();
25
26 cylinder.setX( 2 ); // set new x-coordinate
27 cylinder.setY( 2 ); // set new y-coordinate
28 cylinder.setRadius( 4.25 ); // set new radius
29 cylinder.setHeight( 10 ); // set new height
30
31 // display new cylinder value
32 cout << "\n\nThe new location and radius of circle are\n";
33 cylinder.print();
34
35 // display floating-point values with 2 digits of precision
36 cout << fixed << setprecision( 2 );
37
38 // display cylinder's diameter
39 cout << "\n\nDiameter is " << cylinder.getDiameter();
40
41 // display cylinder's circumference
42 cout << "\nCircumference is "
43 << cylinder.getCircumference();
44
45 // display cylinder's area
46 cout << "\nArea is " << cylinder.getArea();
47
48 // display cylinder's volume
49 cout << "\nVolume is " << cylinder.getVolume();
50
51 cout << endl;
52
53 return 0; // indicates successful termination
54
55 } // end main

X coordinate is 12
Y coordinate is 23
Radius is 2.5
Height is 5.7

The new location and radius of circle are

Center = [2, 2]; Radius = 4.25; Height = 10

Diameter is 8.50
Circumference is 26.70
Area is 380.53
Volume is 567.45

Fig. 9.24 Point/Circle/Cylinder hierarchy test program. (Part 2 of 2.)

Using the point/circle/cylinder example, we have shown the use and benefits of inher-
itance. We were able to develop classes Circle4 and Cylinder much more quickly by
using inheritance than if we had developed these classes from scratch. Inheritance avoids
duplicating code and the associated code-maintenance problems.
642 Object-Oriented Programming: Inheritance Chapter 9

9.6 Constructors and Destructors in Derived Classes

As we explained in the previous section, instantiating a derived-class object begins a chain
of constructor calls in which the derived-class constructor, before performing its own tasks,
invokes its direct base classs constructor either explicitly or implicitly. Similarly, if the base
class were derived from another class, the base-class constructor would be required to in-
voke the constructor of the next class up in the hierarchy, and so on. The last constructor
called in the chain is defined in the class at the base of the inheritance hierarchy (for example,
class Point3, in the Point3/Circle4/Cylinder hierarchy), whose body actually fin-
ishes executing first. The original derived-class constructors body finishes executing last.
Each base-class constructor initializes the base-class data members that the derived-class ob-
ject inherits. For example, again consider the Point3/Circle4/Cylinder hierarchy
from Fig. 9.18, Fig. 9.20 and Fig. 9.23. When a program creates a Cylinder object, the
Cylinder constructor is called. That constructor calls Circle4s constructor, which in
turn calls Point3s constructor. The Point3 constructor initializes the xy coordinates of
the Cylinder object. When Point3s constructor completes execution, it returns control
to Circle4s constructor, which initializes the Cylinder objects radius. When
Circle4s constructor completes execution, it returns control to Cylinders construc-
tor, which initializes the Cylinder objects height.
Software Engineering Observation 9.6
When a program creates a derived-class object, the derived-class constructor immediately
calls the base-class constructor, the base-class constructors body executes, then the de-
rived-class constructors body executes. 9.6

When a derived-class object is destroyed, the program then calls that objects
destructor. This begins a chain of destructor calls in which the derived-class destructor and
the destructors of the direct and indirect base classes execute in reverse of the order in
which the constructors executed. When a derived-class objects destructor is called, the
destructor performs its task, then invokes the destructor of the next base class in the hier-
archy. This process repeats until the destructor of the final base class at the top of the hier-
archy is called. Then the object is removed from memory.
Software Engineering Observation 9.7
Suppose that we create an object of a derived class where both the base class and the derived
class contain objects of other classes. When an object of that derived class is created, first
the constructors for the base classs member objects execute, then the base-class constructor
executes, then the constructors for the derived classs member objects execute, then the de-
rived classs constructor executes. Destructors are called in the reverse of the order in which
their corresponding constructors are called. 9.7

Base-class constructors, destructors and assignment operators are not inherited by

derived classes. Derived-class constructors and assignment operators, however, can call base-
class constructors and assignment operators.
Our next example revisits the point/circle hierarchy by defining class Point4
(Fig. 9.25Fig. 9.26) and class Circle5 (Fig. 9.27Fig. 9.28) that contain constructors
and destructors, each of which prints a message when it is invoked.
Class Point4 (Fig. 9.25Fig. 9.26) contains the features from class Point
(Fig. 9.4Fig. 9.5). We modified the constructor (lines 1118 of Fig. 9.26) and included a
destructor (lines 2127), each of which outputs a line of text upon its invocation.
 Chapter 9 Object-Oriented Programming: Inheritance 643

1 // Fig. 9.25: point4.h

2 // Point4 class definition represents an x-y coordinate pair.
3 #ifndef POINT4_H
4 #define POINT4_H
5
6 class Point4 {
7
8 public:
9 Point4( int = 0, int = 0 ); // default constructor
10 ~Point4(); // destructor
11
12 void setX( int ); // set x in coordinate pair
13 int getX() const; // return x from coordinate pair
14
15 void setY( int ); // set y in coordinate pair
16 int getY() const; // return y from coordinate pair
17
18 void print() const; // output Point3 object
19
20 private:
21 int x; // x part of coordinate pair
22 int y; // y part of coordinate pair
23
24 }; // end class Point4
25
26 #endif

Fig. 9.25 Point4 class header file.

1 // Fig. 9.26: point4.cpp

2 // Point4 class member-function definitions.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 #include "point4.h" // Point4 class definition
9
10 // default constructor
11 Point4::Point4( int xValue, int yValue )
12 : x( xValue ), y( yValue )
13 {
14 cout << "Point4 constructor: ";
15 print();
16 cout << endl;
17
18 } // end Point4 constructor
19
20 // destructor
21 Point4::~Point4()
22 {
23 cout << "Point4 destructor: ";

Fig. 9.26 Point4 base class contains a constructor and a destructor. (Part 1 of 2.)
 644 Object-Oriented Programming: Inheritance Chapter 9

24 print();
25 cout << endl;
26
27 } // end Point4 destructor
28
29 // set x in coordinate pair
30 void Point4::setX( int xValue )
31 {
32 x = xValue; // no need for validation
33
34 } // end function setX
35
36 // return x from coordinate pair
37 int Point4::getX() const
38 {
39 return x;
40
41 } // end function getX
42
43 // set y in coordinate pair
44 void Point4::setY( int yValue )
45 {
46 y = yValue; // no need for validation
47
48 } // end function setY
49
50 // return y from coordinate pair
51 int Point4::getY() const
52 {
53 return y;
54
55 } // end function getY
56
57 // output Point4 object
58 void Point4::print() const
59 {
60 cout << '[' << getX() << ", " << getY() << ']';
61
62 } // end function print

Fig. 9.26 Point4 base class contains a constructor and a destructor. (Part 2 of 2.)

Class Circle5 (Fig. 9.27Fig. 9.28) contains features from class Circle4
(Fig. 9.19Fig. 9.20). We modified the constructor (lines 1120 of Fig. 9.28) and included
a destructor (lines 2329), each of which outputs a line of text upon its invocation.

1 // Fig. 9.27: circle5.h

2 // Circle5 class contains x-y coordinate pair and radius.
3 #ifndef CIRCLE5_H
4 #define CIRCLE5_H

Fig. 9.27 Circle5 class header file. (Part 1 of 2.)

 Chapter 9 Object-Oriented Programming: Inheritance 645

5
6 #include "point4.h" // Point4 class definition
7
8 class Circle5 : public Point4 {
9
10 public:
11
12 // default constructor
13 Circle5( int = 0, int = 0, double = 0.0 );
14
15 ~Circle5(); // destructor
16 void setRadius( double ); // set radius
17 double getRadius() const; // return radius
18
19 double getDiameter() const; // return diameter
20 double getCircumference() const; // return circumference
21 double getArea() const; // return area
22
23 void print() const; // output Circle5 object
24
25 private:
26 double radius; // Circle5's radius
27
28 }; // end class Circle5
29
30 #endif

Fig. 9.27 Circle5 class header file. (Part 2 of 2.)

1 // Fig. 9.28: circle5.cpp

2 // Circle5 class member-function definitions.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 #include "circle5.h" // Circle5 class definition
9
10 // default constructor
11 Circle5::Circle5( int xValue, int yValue, double radiusValue )
12 : Point4( xValue, yValue ) // call base-class constructor
13 {
14 setRadius( radiusValue );
15
16 cout << "Circle5 constructor: ";
17 print();
18 cout << endl;
19
20 } // end Circle5 constructor

Fig. 9.28 Circle5 class inherits from class Point4. (Part 1 of 2.)
 646 Object-Oriented Programming: Inheritance Chapter 9

21
22 // destructor
23 Circle5::~Circle5()
24 {
25 cout << "Circle5 destructor: ";
26 print();
27 cout << endl;
28
29 } // end Circle5 destructor
30
31 // set radius
32 void Circle5::setRadius( double radiusValue )
33 {
34 radius = ( radiusValue < 0.0 ? 0.0 : radiusValue );
35
36 } // end function setRadius
37
38 // return radius
39 double Circle5::getRadius() const
40 {
41 return radius;
42
43 } // end function getRadius
44
45 // calculate and return diameter
46 double Circle5::getDiameter() const
47 {
48 return 2 * getRadius();
49
50 } // end function getDiameter
51
52 // calculate and return circumference
53 double Circle5::getCircumference() const
54 {
55 return 3.14159 * getDiameter();
56
57 } // end function getCircumference
58
59 // calculate and return area
60 double Circle5::getArea() const
61 {
62 return 3.14159 * getRadius() * getRadius();
63
64 } // end function getArea
65
66 // output Circle5 object
67 void Circle5::print() const
68 {
69 cout << "Center = ";
70 Point4::print(); // invoke Point4's print function
71 cout << "; Radius = " << getRadius();
72
73 } // end function print

Fig. 9.28 Circle5 class inherits from class Point4. (Part 2 of 2.)
 Chapter 9 Object-Oriented Programming: Inheritance 647

Figure 9.29 demonstrates the order in which constructors and destructors are called for
objects of classes that are part of an inheritance hierarchy. Function main (lines 1129)
begins by instantiating a Point4 object (line 15) in a separate block inside main (lines 13
17). The object goes in and out of scope immediately (the end of the block is reached as soon

1 // Fig. 9.29: fig09_29.cpp

2 // Display order in which base-class and derived-class
3 // constructors are called.
4 #include <iostream>
5
6 using std::cout;
7 using std::endl;
8
9 #include "circle5.h" // Circle5 class definition
10
11 int main()
12 {
13 { // begin new scope
14
15 Point4 point( 11, 22 );
16
17 } // end scope
18
19 cout << endl;
20 Circle5 circle1( 72, 29, 4.5 );
21
22 cout << endl;
23 Circle5 circle2( 5, 5, 10 );
24
25 cout << endl;
26
27 return 0; // indicates successful termination
28
29 } // end main

Point4 constructor: [11, 22]

Point4 destructor: [11, 22]

Point4 constructor: [72, 29]

Circle5 constructor: Center = [72, 29]; Radius = 4.5

Point4 constructor: [5, 5]

Circle5 constructor: Center = [5, 5]; Radius = 10

Circle5 destructor: Center = [5, 5]; Radius = 10

Point4 destructor: [5, 5]
Circle5 destructor: Center = [72, 29]; Radius = 4.5
Point4 destructor: [72, 29]

Fig. 9.29 Constructor and destructor call order.

648 Object-Oriented Programming: Inheritance Chapter 9

as the object is created), so both the Point4 constructor and destructor are called. Next,
line 20 instantiates Circle5 object circle1. This invokes the Point4 constructor to
perform output with values passed from the Circle5 constructor, then performs the output
specified in the Circle5 constructor. Line 23 then instantiates Circle5 object
circle2. Again, the Point4 and Circle5 constructors are both called. Note that, in
each case, the body of the Point4 constructor is executed before the body of the
Circle5 constructor executes. When the end of main is reached, the destructors are
called for objects circle1 and circle2. But, because destructors are called in the
reverse order of their corresponding constructors, the Circle5 destructor and Point4
destructor are called (in that order) for object circle2, then the Circle5 and Point4
destructors are called (in that order) for object circle1.

9.7 Uses A and Knows A Relationships

Inheritance and composition encourage software reuse by creating classes that take advan-
tage of functionality and data defined in existing classes. There are other ways to use the
services of classes. Although a person object is not a car and a person object does not con-
tain a car, a person object certainly uses a car. A function uses an object simply by calling
a non-private member function of that object using a pointer, reference or the object
name itself.
An object can be aware of another object. Knowledge networks frequently have such
relationships. One object can contain a pointer handle or a reference handle to another
object to be aware of that object. In this case, one object is said to have a knows a relation-
ship with the other object; this is sometimes called an association.

9.8 public, protected and private Inheritance

When deriving a class from a base class, the base class may be inherited through public,
protected or private inheritance. Use of protected and private inheritance is
rare and each should be used only with great care; we normally use public inheritance in
this book. (Chapter 17 demonstrates private inheritance as an alternative to composi-
tion.) Figure 9.30 summarizes for each type of inheritance the accessibility of base-class
members in a derived class. The first column contains the base-class member-access
specifiers.
When deriving a class from a public base class, public members of the base class
become public members of the derived class and protected members of the base
class become protected members of the derived class. A base classs private mem-
bers are never accessible directly from a derived class, but can be accessed through calls to
the public and protected members of the base class.
When deriving from a protected base class, public and protected members
of the base class become protected members of the derived class. When deriving from
a private base class, public and protected members of the base class become
private members (e.g., the functions become utility functions) of the derived class.
Private and protected inheritance are not is-a relationships.
 Chapter 9 Object-Oriented Programming: Inheritance 649

Base-class Type of inheritance

member-
access public protected private
specifier inheritance inheritance inheritance

public in derived class. protected in derived private in derived class.

class.
public

Can be accessed directly by Can be accessed directly by

non-static member func- Can be accessed directly by non-static member func-
tions, friend functions and non-static member func- tions and friend
nonmember functions. tions and friend functions.
functions.
protected in derived class. protected in derived class. private in derived class.
protected

Can be accessed directly Can be accessed directly Can be accessed directly

by non-static member by non-static member by non-static member
functions and friend functions and friend functions and friend
functions. functions'. functions.
Hidden in derived class. Hidden in derived class. Hidden in derived class.

Can be accessed by non- Can be accessed by non- Can be accessed by non-

private

static member functions static member functions static member functions

and friend functions and friend functions and friend functions
through public or through public or through public or
protected member protected member func- protected member
functions of the base class. tions of the base class. functions of the base class.

Fig. 9.30 Summary of base-class member accessibility in a derived class.

9.9 Software Engineering with Inheritance

In this section, we discuss the use of inheritance to customize existing software. When we use
inheritance to create a new class from an existing one, the new class inherits the data members
and member functions of the existing class. We can customize the new class to meet our needs
by including additional members and by redefining base-class members. This is done in C++
without the derived-class programmer accessing the base classs source code. The derived
class must be able to link to the base classs object code. This powerful capability is attractive
to independent software vendors (ISVs). ISVs can develop proprietary classes for sale or li-
cense and make these classes available to users in object-code format. Users then can derive
new classes from these library classes rapidly and without accessing the ISVs proprietary
source code. All the ISVs need to supply with the object code are the header files.
Sometimes, it is difficult for students to appreciate the scope of problems faced by
designers who work on large-scale software projects in industry. People experienced with
such projects say that effective software reuse improves the software-development process.
Object-oriented programming facilitates software reuse, thus shortening development times.
The availability of substantial and useful class libraries delivers the maximum benefits
of software reuse through inheritance. Interest in class libraries is growing exponentially.
Just as shrink-wrapped software produced by independent software vendors became an
650 Object-Oriented Programming: Inheritance Chapter 9

explosive-growth industry with the arrival of the personal computer, so, too, is the creation
and sale of class libraries. Application designers build their applications with these
libraries, and library designers are being rewarded by having their libraries included with
the applications. The standard C++ libraries that are shipped with C++ compilers tend to be
rather general purpose and limited in scope. However, there is massive worldwide commit-
ment to the development of class libraries for a huge variety of applications arenas.
Software Engineering Observation 9.8
At the design stage in an object-oriented system, the designer often determines that certain
classes are closely related. The designer should factor out common attributes and behav-
iors and place these in a base class. Then use inheritance to form derived classes, endowing
them with capabilities beyond those inherited from the base class. 9.8

Software Engineering Observation 9.9

The creation of a derived class does not affect its base classs source code. Inheritance pre-
serves the integrity of a base class. 9.9

Software Engineering Observation 9.10

Just as designers of non-object-oriented systems should avoid proliferation of functions, de-
signers of object-oriented systems should avoid proliferation of classes. Proliferation of
classes creates management problems and can hinder software reusability, because it be-
comes difficult for a client to locate the most appropriate class of a huge class library. The
alternative is to create fewer classes that provide more substantial functionality, but such
classes might provide too much functionality. 9.10

Performance Tip 9.3

If classes produced through inheritance are larger than they need to be (i.e., contain too
much functionality), memory and processing resources might be wasted. Inherit from the
class whose functionality is closest to what is needed. 9.3

Reading derived-class definitions can be confusing, because inherited members are not
shown physically in the derived class, but nevertheless are present in the derived classes. A
similar problem exists when documenting derived-class members.
In this chapter, we introduced inheritancethe ability to create classes by absorbing
an existing classs data members and member functions, and embellishing these with new
capabilities. In Chapter 10, we build upon our discussion of inheritance by introducing
polymorphisman object-oriented technique that enables us to write programs that handle,
in a more general manner, a wide variety of classes related by inheritance. After studying
Chapter 10, you will be familiar with classes, encapsulation, inheritance and polymor-
phismthe most crucial aspects of object-oriented programming.

9.10 [Optional Case Study] Thinking About Objects:

Incorporating Inheritance into the Elevator Simulation
We now examine our simulation design to decide whether it might benefit from inheritance.
In the previous Thinking About Objects sections, we have been treating Elevator-
Button and FloorButton as separate classes. In fact, these classes have much in com-
mon; each is a kind of a button. To apply inheritance, we first look for commonality
between these classes. We then extract this commonality, place it into base class Button
and derive classes ElevatorButton and FloorButton from Button.
Chapter 9 Object-Oriented Programming: Inheritance 651

Let us now examine the similarities between classes ElevatorButton and

FloorButton. Figure 9.31 shows the attributes and operations of both classes, as
declared in their header files from Chapter 7 (Fig. 7.37 and Fig. 7.39, respectively). The
classes have in common one attribute (pressed) and two operations (pressButton
and resetButton). We place these three elements in base-class Button, then Eleva-
torButton and FloorButton inherit the attributes and operations of Button. In our
previous implementation, ElevatorButton and FloorButton each declared a refer-
ence to an object of class Elevatorclass Button also should contain this reference.
Figure 9.32 shows our modified elevator simulator design, which incorporates inher-
itance. Class Floor is composed of one object of class FloorButton and one object of
class Light. In addition, class Elevator is composed of one object of class Eleva-
torButton, one object of class Door and one object of class Bell. A solid line with a
hollow arrowhead extends from each of the derived classes to the base classthis line indi-
cates that classes FloorButton and ElevatorButton inherit from class Button.
One question remains: Should the derived classes redefine any of the base-class
member functions? If we compare the public member functions of each class (Fig. 7.38 and
Fig. 7.40), we notice that the resetButton member function is identical for both
classes. This function does not need to be redefined. However, the implementation of
member function pressButton differs for each class. Class ElevatorButton con-
tains the pressButton code

pressed = true;
cout << "elevator button tells elevator to prepare to leave"
<< endl;
elevatorRef.prepareToLeave( true );

whereas class FloorButton contains this different pressButton code

pressed = true;
cout << "floor " << floorNumber
<< " button summons elevator" << endl;
elevatorRef.summonElevator( floorNumber );

The first line of each block of code is identical, but the remaining sections are different.
Therefore, each derived class must redefine the base-class Button member function
pressButton.

ElevatorButton FloorButton
- pressed : Boolean = false - pressed : Boolean = false
- floorNumber : Integer
+ pressButton( ) + pressButton( )
+ resetButton( ) + resetButton( )

Fig. 9.31 Attributes and operations of classes ElevatorButton and

FloorButton.
652 Object-Oriented Programming: Inheritance Chapter 9

Clock

1
1 1
Building
1

1
Scheduler
1
1

Creates *
0..1 0..1
Person
occupant passenger
{xor}
2 1 1
2 Services 1
Floor Elevator
2 1
1 1 1
Summons
1 1 2 1 1
Light FloorButton ElevatorButton Bell
1
Door

Button

Fig. 9.32 Class diagram incorporating inheritance into the elevator-simulator.

Figure 9.33 lists the header file for the base class Button.2 We declare public
member functions pressButton and resetButton (lines 1314) and private data
member pressed of type bool (line 22). Notice the declaration of the reference to an
Elevator object in line 19 and the corresponding parameter to the constructor in line 11.
We show how to initialize the reference when we discuss the code for the derived classes.
The derived classes perform two different actions. Class ElevatorButton invokes
the prepareToLeave member function of class Elevator; class FloorButton
invokes the summonElevator member function. Thus, both classes need access to the

2. The benefit of encapsulation is that no other files in our elevator simulation need to be changed.
We simply substitute the new elevatorButton and floorButton header and implementa-
tion files for the old ones and add the files for class Button.
 Chapter 9 Object-Oriented Programming: Inheritance 653

elevatorRef data member of the base class; however, this data member should not be
available to non-Button objects. Therefore, we place the elevatorRef data member
in the protected section of Button. Only base-class member functions directly manip-
ulate data member pressed, so we declare this data member as private. Derived
classes do not need to access pressed directly.
Figure 9.34 lists the implementation file for class Button. Line 12 in the constructor
initializes the reference to the elevator. The constructor and destructor display messages
indicating that they are running, and the pressButton and resetButton member
functions manipulate private data member pressed.

1 // Fig. 9.33: button.h

2 // Definition for class Button.
3 #ifndef BUTTON_H
4 #define BUTTON_H
5
6 class Elevator; // forward declaration
7
8 class Button {
9
10 public:
11 Button( Elevator & ); // constructor
12 ~Button(); // destructor
13 void pressButton(); // sets button on
14 void resetButton(); // resets button off
15
16 protected:
17
18 // reference to button's elevator
19 Elevator &elevatorRef;
20
21 private:
22 bool pressed; // state of button
23
24 }; // end class Button
25
26 #endif // BUTTON_H

Fig. 9.33 Button class header file.

1 // Fig. 9.34: button.cpp

2 // Member function definitions for class Button.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 #include "button.h" // Button class definition
9

Fig. 9.34 Button class implementation filebase class for ElevatorButton

and FloorButton. (Part 1 of 2.)
 654 Object-Oriented Programming: Inheritance Chapter 9

10 // constructor
11 Button::Button( Elevator &elevatorHandle )
12 : elevatorRef( elevatorHandle ), pressed( false )
13 {
14 cout << "button constructed" << endl;
15
16 } // end Button constructor
17
18 // destructor
19 Button::~Button()
20 {
21 cout << "button destructed" << endl;
22
23 } // end Button destructor
24
25 // press button
26 void Button::pressButton()
27 {
28 pressed = true;
29
30 } // end function pressButton
31
32 // reset button
33 void Button::resetButton()
34 {
35 pressed = false;
36
37 } // end function resetButton

Fig. 9.34 Button class implementation filebase class for ElevatorButton

and FloorButton. (Part 2 of 2.)

Figure 9.35 contains the header file for class ElevatorButton. Line 8 indicates
that the class inherits from class Button. This inheritance means that class Elevator-
Button contains the protected elevatorRef data member and the public press-
Button and resetButton member functions of the base class. In line 13, we provide
a function prototype for pressButton to signal our intent to redefine that member func-
tion in the .cpp file. We discuss the pressButton implementation momentarily.
The constructor takes as a parameter a reference to class Elevator (line 11). We dis-
cuss the necessity for this parameter when we discuss the classs implementation. Notice,
however, that we do not need to include a forward declaration of class Elevator in the
derived class, because the base-class header file contains the forward reference.

1 // Fig. 9.35: elevatorButton.h

2 // ElevatorButton class definition.
3 #ifndef ELEVATORBUTTON_H
4 #define ELEVATORBUTTON_H
5
6 #include "button.h" // Button class definition

Fig. 9.35 ElevatorButton class header file. (Part 1 of 2.)

 Chapter 9 Object-Oriented Programming: Inheritance 655

7
8 class ElevatorButton : public Button {
9
10 public:
11 ElevatorButton( Elevator & ); // constructor
12 ~ElevatorButton(); // destructor
13 void pressButton(); // press the button
14
15 }; // end class ElevatorButton
16
17 #endif // ELEVATORBUTTON_H

Fig. 9.35 ElevatorButton class header file. (Part 2 of 2.)

Figure 9.36 lists the implementation file of class ElevatorButton. The class con-
structors and destructors display messages to indicate that these functions are executing.
Line 13 passes the Elevator reference to the base-class constructor.

1 // Fig. 9.36: elevatorButton.cpp:

2 // Member-function definitions for class ElevatorButton.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 #include "elevatorButton.h" // ElevatorButton class definition
9 #include "elevator.h" // Elevator class definition
10
11 // constructor
12 ElevatorButton::ElevatorButton( Elevator &elevatorHandle )
13 : Button( elevatorHandle )
14 {
15 cout << "elevator button constructed" << endl;
16
17 } // end ElevatorButton constructor
18
19 // destructor
20 ElevatorButton::~ElevatorButton()
21 {
22 cout << "elevator button destructed" << endl;
23
24 } // end ~ElevatorButton destructor
25
26 // press button and signal elevator to prepare to leave floor
27 void ElevatorButton::pressButton()
28 {
29 Button::pressButton();
30 cout << "elevator button tells elevator to prepare to leave"
31 << endl;
32 elevatorRef.prepareToLeave( true );
33
34 } // end function pressButton

Fig. 9.36 ElevatorButton class member-function definitions.

 656 Object-Oriented Programming: Inheritance Chapter 9

Member function pressButton first calls the pressButton member function

(line 29) in base class Button; this call sets to true the pressed attribute of class
Button. Line 32 notifies the elevator to move to the other floor by passing true to
member function prepareToLeave.
Figure 9.37 lists the header file for class FloorButton. The only difference between
this file and the header file for class ElevatorButton is the addition in line 16 of the
floorNumber data member. We use this data member to distinguish the floors in the
simulation output messages. The constructor declaration includes a parameter of type int
(line 11), so the FloorButton object can initialize attribute floorNumber.
Figure 9.38 shows the implementation of class FloorButton. Lines 1314 pass the
Elevator reference to the base-class constructor and initialize the floorNumber data
member. The constructor (lines 1219) and destructor (lines 2227) output appropriate
messages, using data member floorNumber. The redefined pressButton member
function (lines 3039) first calls member function pressButton (line 32) in the base
class, then invokes the elevators summonElevator member function (line 37), passing
floorNumber to indicate the floor that summoned the elevator.

1 // Fig. 9.37: floorButton.h

2 // FloorButton class definition.
3 #ifndef FLOORBUTTON_H
4 #define FLOORBUTTON_H
5
6 #include "button.h" // Button class definition
7
8 class FloorButton : public Button {
9
10 public:
11 FloorButton( int, Elevator & ); // constructor
12 ~FloorButton(); // destructor
13 void pressButton(); // press the button
14
15 private:
16 const int floorNumber; // button's floor number
17
18 }; // end class FloorButton
19
20 #endif // FLOORBUTTON_H

Fig. 9.37 FloorButton class header file.

1 // Fig. 9.38: floorButton.cpp

2 // Member-function definitions for class FloorButton.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 #include "floorButton.h"
9 #include "elevator.h"

Fig. 9.38 FloorButton class member-function definitions. (Part 1 of 2.)

 Chapter 9 Object-Oriented Programming: Inheritance 657

10
11 // constructor
12 FloorButton::FloorButton( int floor, Elevator &elevatorHandle )
13 : Button( elevatorHandle ),
14 floorNumber( floor )
15 {
16 cout << "floor " << floorNumber << " button constructed"
17 << endl;
18
19 } // end FloorButton constructor
20
21 // destructor
22 FloorButton::~FloorButton()
23 {
24 cout << "floor " << floorNumber << " button destructed"
25 << endl;
26
27 } // end ~FloorButton destructor
28
29 // press the button
30 void FloorButton::pressButton()
31 {
32 Button::pressButton();
33 cout << "floor " << floorNumber
34 << " button summons elevator" << endl;
35
36 // call elevator to this floor
37 elevatorRef.summonElevator( floorNumber );
38
39 } // end function pressButton

Fig. 9.38 FloorButton class member-function definitions. (Part 2 of 2.)

We now have completed the implementation for the elevator-simulator case study that
we have been developing since Chapter 2. One significant architectural opportunity
remains. You might have noticed that classes Button, Door and Light have much in
common. Each of these classes contains a state attribute and corresponding set on and
set off operations. Class Bell also bears some similarity to these other classes. Object-
oriented thinking tells us that we should place commonalities in one or more base classes,
from which we should then use inheritance to form appropriate derived classes. We leave
this implementation to the reader as an exercise. We suggest that you begin by modifying
the class diagram in Fig. 9.32. [Hint: Button, Door and Light are essentially toggle
classesthey each have state, set on and set off capabilities; Bell is a thinner
class, with only a single operation and no state.]
We sincerely hope that this elevator simulation case study was a challenging and
meaningful experience for you. We employed a carefully developed, incremental object-
oriented process to produce a UML-based design for our elevator simulator. From this
design, we produced a substantial working C++ implementation using key programming
notions, including classes, objects, encapsulation, visibility, composition and inheritance.
658 Object-Oriented Programming: Inheritance Chapter 9

In the remaining chapters of the book, we present many additional key C++ technologies.
We would be grateful if you would take a moment to send your comments, criticisms and
suggestions for improving this case study to us at [email protected].

SUMMARY
Software reuse reduces program-development time.
The direct base class of a derived class is the base class from which the derived class inherits (spec-
ified by the class name to the right of the : in the first line of a class definition). An indirect base
class of a derived class is two or more levels up the class hierarchy from that derived class.
With single inheritance, a class is derived from one base class. With multiple inheritance, a class
is derived from more than one direct base class.
A derived class can include its own data members and member functions, so a derived class is of-
ten larger than its base class.
A derived class is more specific than its base class and represents a smaller group of objects.
Every object of a derived class is also an object of that classs base class. However, a base-class
object is not an object of that classs derived classes.
Derived-class member functions can access protected base-class members directly.
An is-a relationship represents inheritance. In an is-a relationship, an object of a derived class
also can be treated as an object of its base class.
A has-a relationship represents composition. In a has-a relationship, a class object contains
one or more objects of other classes as members.
A derived class cannot access the private members of its base class directly; allowing this would
violate the encapsulation of the base class. A derived class can, however, access the public and
protected members of its base class directly.
When a base-class member function is inappropriate for a derived class, that member function can
be redefined in the derived class with an appropriate implementation.
Single-inheritance relationships form tree-like hierarchical structuresa base class exists in a hi-
erarchical relationship with its derived classes.
It is possible to treat base-class objects and derived-class objects similarly; the commonality
shared between the object types is expressed in the data members and member functions of the
base class.
A base classs public members are accessible anywhere that the program has a handle to an object
of that base class or to an object of one of that base classs derived classes.
A base classs private members are accessible only within the definition of that base class or from
friends of that class.
A base classs protected members have an intermediate level of protection between public and pri-
vate access. A base classs protected members can be accessed by members and friends of that
base class and by members and friends of any classes derived from that base class.
Unfortunately, protected data members often yield two major problems. First, the derived-class
object does not have to use a set function to change the value of the base-classs protected data.
Second, derived-class member functions are more likely to depend on base-class implementation
details.
When a derived-class member function redefines a base-class member function, the base-class
member function can be accessed from the derived class by preceding the base-class member func-
tion name with the base-class name and the scope resolution operator (::).
Chapter 9 Object-Oriented Programming: Inheritance 659

When an object of a derived class is instantiated, the base classs constructor is called immediately
(either explicitly or implicitly) to initialize the base-class data members in the derived-class object
(before the derived-class data members are initialized).
Declaring data members private, while providing non-private member functions to manipulate
and perform validation checking on this data, enforces good software engineering.
When a derived-class object is destroyed, the destructors are called in the reverse order of the con-
structorsfirst the derived-class destructor is called, then the base-class destructor is called.
When deriving a class from a base class, the base class may be declared as either public, pro-
tected or private.
When deriving a class from a public base class, public members of the base class become
public members of the derived class, and protected members of the base class become
protected members of the derived class.
When deriving a class from a protected base class, public and protected members of the
base class become protected members of the derived class.
When deriving a class from a private base class, public and protected members of the
base class become private members of the derived class.
Knows a relationships are examples of objects containing pointers or references to other objects
so they can be aware of those objects.

TERMINOLOGY
abstraction inheritance
association is-a relationship
base class knows-a relationship
base-class constructor member access control
base-class default constructor member class
base-class destructor member object
base-class initializer multiple inheritance
class hierarchy object-oriented programming (OOP)
composition private base class
customize software private inheritance
derived class protected base class
derived-class constructor protected inheritance
derived-class destructor protected keyword
direct base class protected member of a class
friend of a base class public base class
friend of a derived class public inheritance
has-a relationship redefine a base-class member function
hierarchical relationship single inheritance
indirect base class software reusability
infinite recursion error uses-a relationship

SELF-REVIEW EXERCISES
9.1 Fill in the blanks in each of the following statements:
a) is a form of software reusability in which new classes absorb the data and
behaviors of existing classes and embellish these classes with new capabilities.
b) A base classs members can be accessed only in the base-class definition or
in derived-class definitions.
660 Object-Oriented Programming: Inheritance Chapter 9

c) In a(n) relationship, an object of a derived class also can be treated as an ob-

ject of its base class.
d) In a(n) relationship, a class object has one or more objects of other classes
as members.
e) In single inheritance, a class exists in a(n) relationship with its derived class-
es.
f) A base classs members are accessible anywhere that the program has a han-
dle to an object of that base class or to an object of one of its derived classes.
g) A base classs protected access members have a level of protection between those of
public and access.
h) C++ provides for , which allows a derived class to inherit from many base
classes, even if these base classes are unrelated.
i) When an object of a derived class is instantiated, the base classs is called
implicitly or explicitly to do any necessary initialization of the base-class data members
in the derived-class object.
j) When deriving a class from a base class with public inheritance, public members of
the base class become members of the derived class, and protected
members of the base class become members of the derived class.
k) When deriving a class from a base class with protected inheritance, public mem-
bers of the base class become members of the derived class, and pro-
tected members of the base class become members of the derived class.
9.2 State whether each of the following is true or false. If false, explain why.
a) It is possible to treat base-class objects and derived-class objects similarly.
b) Base-class constructors are not inherited by derived classes.
c) A has-a relationship is implemented via inheritance.
d) A Car class has an is a relationship with its SteeringWheel and Brakes.
e) Inheritance encourages the reuse of proven high-quality software.

ANSWERS TO SELF-REVIEW EXERCISES

9.1 a) Inheritance. b) protected. c) is-a or inheritance. d) has-a or composition or ag-
gregation. e) hierarchical. f) public. g) private. h) multiple inheritance. i) constructor.
j) public, protected. k) protected, protected.
9.2 a) True. b) True. c) False. A has-a relationship is implemented via composition. An is-
a relationship is implemented via inheritance. d) False. This is an example of a hasa relationship.
Class Car has an isa relationship with class Vehicle. e) True.

EXERCISES
9.3 Many programs written with inheritance could be written with composition instead, and vice
versa. Rewrite classes Point3, Circle4 and Cylinder to use composition, rather than inherit-
ance. After you do this, assess the relative merits of the two approaches for the Point3, Circle4,
Cylinder problem, as well as for object-oriented programs in general. Which approach is more nat-
ural, why?
9.4 Some programmers prefer not to use protected access because it breaks the encapsulation
of the base class. Discuss the relative merits of using protected access vs. using private access
in base classes.
9.5 Rewrite the case study in Section 9.5 as a Point, Square, Cube program. Do this two
waysonce via inheritance and once via composition.
Chapter 9 Object-Oriented Programming: Inheritance 661

9.6 Write an inheritance hierarchy for class Quadrilateral, Trapezoid, Parallelo-

gram, Rectangle and Square. Use Quadrilateral as the base class of the hierarchy. Make
the hierarchy as deep (i.e., as many levels) as possible. The private data of Quadrilateral
should be the xy coordinate pairs for the four endpoints of the Quadrilateral.
9.7 Modify classes Point3, Circle4 and Cylinder to contain destructors. Then modify the
program of Fig. 9.29 to demonstrate the order in which constructors and destructors are invoked in
this hierarchy.
9.8 Write down all the shapes you can think ofboth two dimensional and three dimensional
and form those shapes into a shape hierarchy. Your hierarchy should have base class Shape from
which class TwoDimensionalShape and class ThreeDimensionalShape are derived. Once
you have developed the hierarchy, define each of the classes in the hierarchy. We will use this hier-
archy in the exercises of Chapter 10 to process all shapes as objects of base-class Shape. (This tech-
nique, called polymorphism, is the subject of Chapter 10.)