Lecture 8
Understanding Inheritance
COSC 156
C++ Programming
1
Objectives
• Inheritance and its benefits
• Create a derived class
• Restrictions imposed with inheritance
• Choose a class access specifier
• Override and overload functions in a child class
• Use a constructor initialization list
• Provide for a base class constructor within a
derived class
• Override the class access specifier
• Use multiple inheritance
• Special problems posed by multiple inheritance
• Use virtual inheritance
2
Understanding Inheritance
• Objects used in computer programs also are
easier to understand if you can place them within
a hierarchy of inheritance
• Suppose you have written several programs with
a class named Student
• The FirstYearStudent class inherits from the
Student class, or is derived from it
• The Student class is called a parent class, base
class, superclass, or ancestor; the
FirstYearStudent class is called a child class,
derived class, subclass, or descendant
• When you override a function, you substitute one
version of the function for another
3
Understanding the Advantages
Provided by Inheritance
• Inheritance is considered a basic building block
of object-oriented programming
• Programs in which you derive new classes from
existing classes offer several advantages:
– You save time because much of the code needed for
your class is already written
– You save additional time because the existing code
has already been tested—that is, you know it works
correctly; it is reliable
4
Understanding the Advantages
Provided by Inheritance
• Advantages of using derived classes:
– You save even more time because you already understand
how the base class works, and you can concentrate on the
complexity added as a result of your extensions to the class
– In a derived class, you can extend and revise a parent class
without corrupting the existing parent class features
– If other classes have been derived from the parent class, the
parent class is even more reliable—the more its code has
been used, the more likely it is that logical errors have
already been found and fixed
5
Creating a Derived Class
• The class, named Person, is shown in Figure 9-1
• It contains three fields, and two member functions that set
and display the data field values
6
Creating a Derived Class
• To create a derived class, you include the following
elements in the order listed:
–
–
–
–
–
–
–
–
–
Keyword class
Derived class name
Colon
Class access specifier, either public, private, or protected
Base class name
Opening brace
Class definition statements
Closing brace
Semicolon
7
Creating a Derived Class
• The Customer class shown in Figure 9-2
contains all the members of Person because
it inherits them
8
The Customer Class
9
Creating a Derived Class
Ex8-1.cpp
10
Ex8-2.cpp
Creating a Derived Class
• Create the Convertible class and a
demonstration program
11
Understanding Inheritance
Restrictions
• Member accessibilities of the members of the
base class in the derived classes
12
Understanding Inheritance
Restrictions
• The protected specifier allows members to be used
by class member functions and by derived classes,
but not by other parts of a program
13
Choosing the Class Access
Specifier
• C++ programmers usually use the public access
specifier for inheritance
• If a derived class uses the public access specifier,
then the following statements are true:
– Base class members that are public remain public in the
derived class
– Base class members that are protected remain protected in
the derived class
– Base class members that are private are inaccessible in the
derived class
14
Choosing the Class Access
Specifier
• If a derived class uses the protected access
specifier, then the following statements are true:
– Base class members that are public become protected in
the derived class
– Base class members that are protected remain protected in
the derived class
– Base class members that are private are inaccessible in the
derived class
15
Choosing the Class Access
Specifier
• If a derived class uses the private access specifier,
then the following statements are true:
– Base class members that are public become private in the
derived class
– Base class members that are protected become private in
the derived class
– Base class members that are private are inaccessible in the
derived class
16
Choosing the Class Access
Specifier
17
Choosing the Class Access
Specifier
18
Choosing the Class Access
Specifier
• A main() program that instantiates an Introvert object
cannot access any of the four data items directly; all four
fields are private to the Introvert class
19
Choosing the Class Access
Specifier
20
Choosing the Class Access
Specifier
• To summarize the use of three class access
specifiers with class data members:
– If a class has private data members, they can be used only
by member functions of that class
– If a class has protected data members, they can be used by
member functions of that class and by member functions of
derived classes
– If a class has public data members, they can be used by
member functions of that class, by member functions of
derived classes, and by any other functions’ including the
main() function of a program
21
Choosing the Class Access
Specifier
• With one generation of inheritance, there are nine possible
combinations, as shown in Table 9-1
• Remember the following:
– Private data can be accessed only by a class’s member
functions (or friend functions), and not by any functions in
derived classes
– If a class serves as a base class, most often its data members
are protected, and its member functions are public
– The access specifier in derived classes is most often public,
so that the derived class can refer to all non-private data and
functions of the base class
– When a class is derived from another derived class, the newly
derived class never has any more liberal access to a base
class member than does its immediate predecessor
22
Summary of Child Class
Member Access Rules
Ex8-3.cpp
check errors
23
Overriding and Overloading
Parent Class Functions
• When a new class is derived from an existing class,
the derived class has access to non-private member
functions in the base class
• The new class also can have its own member
functions
• Those functions can have names that are identical to
the function names in the base class
• Any child class function with the same name and
argument list as the parent overrides the parent
function;
• No overloading across scopes.
24
Overriding and Overloading
Parent Class Functions
25
Overriding and Overloading
Parent Class Functions
26
Overriding and Overloading
Parent Class Functions
Ex8-4.cpp
27
Overriding and Overloading
Parent Class Functions
• The output in Figure 9-21 shows that even though you set
fields for a Person and an Employee by using separate
functions that require separate argument lists, you use
the same outputData() function that exists within the
parent class for both a Person and an Employee
28
Overriding and Overloading
Parent Class Functions
Ex8-4.cpp
29
Overriding and Overloading
Parent Class Functions
• A derived class object can be assigned to a base
class object, as in aPerson = worker;
• The assignment causes each data member to be
copied from worker to aPerson, and leaves off any
data for which the base class doesn’t have members
• The reverse assignment cannot take place without
writing a specialized function
• When any class member function is called, the steps
shown on page 333 of the textbook take place
30
Overriding and Overloading
Parent Class Functions
Ex8-5.cpp
•
In the set of steps outlined on pages 333 and 334 of the textbook,
you create a RaceCar class as a child of the Car class you created
earlier
•
A RaceCar has all the attributes of a Car, but its maximum allowed
speed is higher
•
Overriding a base class member function with a derived member
function demonstrates the concept of polymorphism
31
Using Constructor
Initialization Lists
• Many classes use a constructor function to provide
initial values for fields when a class object is
created; that is, many functions simply contain a
series of assignment statements
• As an alternative to the separate prototype and
implementation of the constructor shown in Figure
9-25, you can implement the constructor within the
declaration section for the class as an inline function
32
The Item Class
33
Using Constructor
Initialization Lists
• As another alternative, you can replace the assignment
statements within a constructor body for Item with a
constructor initialization list
• A constructor initialization list provides values for class fields
in the same statement that contains the constructor definition
34
Using Constructor
Initialization Lists
Ex8-6.cpp
• The constructor initialization list shown in
Figure 9-27 initializes itemNum with the value of
n and itemPrice with the value of p
35
Understanding the Difference
Between Assignment
and Initialization
• The difference between assignment and initialization is often
very subtle, and programmers sometimes mingle the two terms
rather casually
• When you declare a simple scalar variable and give it a value,
you can declare and assign in two separate statements, for
example:
int z;
z = 100;
• Alternatively, you can initialize a variable, declaring it and
assigning it a value within a single statement, for example:
int z = 100;
OR
int z(100);
36
Understanding the Difference
Between Assignment
and Initialization
• There are at least four reasons to understand the
use of constructor initialization lists:
– Many C++ programmers prefer this method, so it is used in
many programs
– Technically, a constructor should initialize rather than
assign values
– Reference variables and constant class members cannot be
assigned values; they must be initialized
– When you create a derived class and instantiate an object, a
parent class object must be constructed first. You add a
constructor initialization list to a derived class constructor
to construct the parent class.
37
Providing for Base Class
Construction
• When you instantiate an object in a C++ program,
you automatically call its constructor function
• This pattern holds true whether you write a custom
constructor or use a default constructor
• When you instantiate a derived class object, a
constructor for its base class is called first, followed
by the derived class constructor
• This format is followed even if the base and derived
classes both have only default constructors
38
Providing for Base Class
Construction
39
Providing for Base Class
Construction
• If PetStoreAnimal were a simple base class, the
PetStoreAnimal class constructor would require just an
integer argument that would be assigned to the petAge
field
• However, because PetStoreAnimal is derived from
PetStoreItem, a PetStoreAnimal object is constructed,
and the PetStoreItem class constructor also will be called
• The prototype for the PetStoreAnimal class constructor
must provide values for all the arguments it needs as well
as all the arguments its parent needs
40
The PetStoreAnimal Class
41
Providing for Base Class
Construction
Ex8-7.cpp
• Figure 9-31 shows one more option for coding the
PetStoreAnimal class
• In this example, the constructor initialization list
initializes both PetStoreItem and petAge
42
Overriding Inherited Access
• Nine inheritance access specifier
combinations are possible: base class
members that are private, protected, or
public can be inherited with private,
protected, or public access
• In addition, you can override the class
access specifier for any specific class
members
43
The DemoBasePerson Class
44
Overriding Inherited Access
• If a derived class, SomewhatShy, uses the protected
access specifier when inheriting from DemoBasePerson,
then the following statements hold true:
– The field named salary, which is private in DemoBasePerson, is
inaccessible in the derived class
– The field named age, which is protected in the base class, remains
protected in the derived class
– The field named initial, which is public in the base class, becomes
protected in the derived class
– The function setPerson() and showPerson(), which are public in
DemoBasePerson, become protected in the derived class
45
Overriding Inherited Access
•
•
•
For the showPerson() function to become public within SomewhatShy,
the highlighted statement in Figure 9-33 must appear in the public
section of the SomewhatShy class
Additionally, the DemoBasePerson class name and scope resolution
operator must appear before the showPerson() function name
Finally, and most oddly, no parentheses appear after the
showPerson() function name within the child class
46
Ex8-8.cpp
Overriding Inherited Access
• However, you can override the inherited access to make an
individual member’s access more conservative
• For most C++ classes, data is private or protected, and
most functions are public
47
More examples
• Ex8-9.cpp
• Ex8-10.cpp
• Ex8-11.cpp
48
Summary
• Inheritance allows you to create classes that derive most
of their attributes from existing classes
• Programs in which you create classes that are derived
from existing classes offer several advantages: you save
time because much of the code needed for your class is
already written and tested
• To create a derived class, you include the keyword class,
the derived class name, a colon, a class access specifier,
and the base class name in the class header; as with
other classes, definition statements within a pair of curly
braces follow
49
Summary
• When a class serves as a base class to others, all of its
members can be used within the child class functions,
except for any private members
• When you define a derived class, you can insert one of
the three class access specifiers (public, private, or
protected) just prior to the base class name
• You can override parent class functions within a child
class
• As an alternative to separate prototypes and
implementation of a constructor, you can use a
constructor initialization list
50
9
Summary
• When you declare a variable without an initial value,
it holds garbage until you make an assignment
• If a base class does not contain a default
constructor, then you must provide a constructor for
use by the derived class
• You can override the class access specifier when it
does not suit your needs for some of the members of
the class
51