The document provides an introduction to inheritance in C++ programming, describing how classes can inherit features from existing classes to promote code reuse. It explains both single and multiple inheritance, the relationship between base and derived classes, and how public and private members are managed during inheritance. Furthermore, it discusses constructors for derived classes and gives examples demonstrating the implementation of inherited behaviors and method overriding.

1. An Introduction To Software
Development Using C++
Class #22:
Inheritance, Part 1

2. Classes Creating New Classes
• Classes can create new classes from existing classes.
• This is a powerful feature because it encourages code
reuse.
• In C++ you can relate two or more classes in more than one
way.
• Two common ways to relate classes in a meaningful way
are:
– Inheritance (“is-a” relationship)
– Composition (aggregation)
(“has-a” relationship)
Image Credit: www.svendirect.com

3. Inheritance
• Let’s create a class called partTimeEmployee
so that we can implement and process the
characteristics of a part time employee.
• Main features of a part-time employee:
– Name
– Pay rate
– # hours worked
Image Credit: www.mccainortho.com

4. Inheritance
• Let us assume that we’ve already created a
class to be able to remember a person’s name.
• Rather than design the class
partTimeEmployee from scratch we want to
be able to extend the definition of the class
personType by adding additional data and / or
methods.
Image Credit: www.wikihow.com

5. Inheritance
• Somebody else may be using personType so we don’t want
to make the necessary changes to the class personType
directly (e.g. edit personType and edit / delete parts of it).
• We want to create the class partTimeEmployee without
making any physical changes to the class personType by
adding only the data and methods that are necessary.
• As an example of this, the class personType already has
methods to store the first name and the last name. We
won’t have to create such methods for the class
partTimeEmployee. The reason that we won’t
is because we’ll inherit these from personType.
Image Credit: en.hdyo.org

6. Inheritance – Another Example
• Assume that we’ve created a class called clockType that we’ve used to
implement the time of day in a program.
• The class clockType has three member variables to store the hours,
minutes, and seconds.
• Our new application, in addition to hours, minutes and seconds, needs to
know the time zone.
• This means that we’d like to extend the definition of clockType to now
include this new information by creating a new class extClockType.
• What this means is that we want to derive
class extClockType by adding a variable,
timeZone, and the necessary methods to
manipulate the time.
Image Credit: www.amazon.com

7. Inheritance
• In both the partTimeEmployee and the
extClockTime cases, C++ allows us to extend the
definition of an existing class to create a new
class.
• What allows us to accomplish this is called the
principal of inheritance.
• Inheritance is a “is-a” relationship.
Example: every employee is a
person.
Image Credit: www.cunningbailey.com

8. Inheritance
• Inheritance allows us to create new classes from existing classes.
• The new classes that we create from existing classes are called the
derived classes.
• The existing classes are called the base classes.
• The derived classes inherit the properties of the base classes.
• Rather than create completely new classes
from scratch, we can now take advantage
of inheritance and reduce software
development complexity.
Image Credit: gailbrenner.com

9. Inheritance
• Each derived class can, in turn, then become a base
class for a future derived class.
• Inheritance can either be a single inheritance or a
multiple inheritance.
• In single inheritance, the derived class is derived from
a single base class.
• In multiple inheritance, the
derived class is derived from
multiple base classes.
Image Credit: www.swiftshift.com

10. Inheritance
• Inheritance can be viewed as being a treelike or hierarchical
structure. Here’s an example:
• Shape is the base class. The classes circle and rectangle are
derived from shape, and the class square is derived from
the class rectangle.
• Every circle and every rectangle is a shape.
Every square is a rectangle.
Image Credit: en.wikipedia.org

11. Inheritance
• General syntax of a derived class is:
• memberAccessSpecifier will be public,
protected, or private. If it is not specified,
then it is assumed to be a private inheritance.
Image Credit: www.canstockphoto.com

12. Public / Private Inheritance
• Assume that we have a class called shape. These statements specify that the class
circle is derived from the class shape and it is a public inheritance:
• On the other hand, consider the following definition of class circle:
• This is a private inheritance. In this definition, the public members of shape
become private members of the class circle.
1 Image Credit: www.forensicmag.com

13. Public / Private Inheritance
• The previous definition of circle is equivalent to:
• What this means is that if we don’t use either the
memberAccessSpecifier public or private, the
public members of a base class are inherited as
private members by default.
Image Credit: www.huffingtonpost.ca

14. Facts About Base & Derived Classes
1. The private members of a base class remain private to the
base class; hence, the members of the derived class
cannot directly access them. In other words, when you
write the definitions of the member functions of the
derived class, even though the private members of the
base class are members of the derived class, the derived
class cannot directly access them.
2. The public members of the base class can be inherited as
either public members or private members by the derived
class. This means that what were public members in the
base class can now become either public or private
members in the derived class.
Image Credit: www.123rf.com

15. Facts About Base & Derived Classes
3. The derived class can contain additional data and or
functions.
4. The derived class can redefine the public member functions
of the base class. That is, in the derived class you can have a
member function with the same name, number and type of
parameters as a function in the base class, but with different
code in the function body. This redefinition will only apply to
objects of the derived class, not to objects of the base class.
Image Credit: www.featurepics.com

16. Facts About Base & Derived Classes
5. All member variables of the base class are
also member variables of the derived class.
Similarly, the member functions of the base
class are also members of the derived class.
Image Credit: www.liveboxcloud.com

17. Redefining / Overriding Member
Functions Of the Base Class
• Let us assume that the class derivedClass was
derived from the class baseClass.
• Assume that both derivedClass and
baseClass have some member variables.
• It follows that the member variables of the class
derivedClass are its own member variables,
together with the member variables of baseClass.
Image Credit: nicodewet.com

18. Redefining / Overriding Member
Functions Of the Base Class
• Suppose that baseClass contains a method print
that prints the values of the variables of
baseClass.
• Now derivedClass contains more variables
than just those inherited from baseClass.
• Suppose that you want to include a method in
derivedClass that will print the variables in
derivedClass.
Image Credit: en.soft-xpansion.eu

19. Redefining / Overriding Member
Functions Of the Base Class
• You can give any name to this new method.
• However, in the class derivedClass you can
also call this new method print – the same
name used by baseClass.
• This is called redefining or
overriding the method of
the base class.
Image Credit: inkondapaper.com

20. Redefining / Overriding Member
Functions Of the Base Class
• Note: To redefine a public method of a base
class in the derived class, the corresponding
class in the derived class must have the same
name, number and types of parameters.
Image Credit: www.abc.net.au

21. Example: rectangleType & boxType
• Class boxType is derived from class
rectangleType and it is a public inheritance.
• All public members of class rectangleType are
public members of class boxType.
• The class boxType also overrides / redefines
the functions print and area.
1 Image Credit: globe-views.com

22. How Can A Derived Class Call A Public
Method In The Base Class?
• If the derived class overrides a public method of the
base class, then to specify a call to that public member
function of the base class , you use the name of the
base class, followed by the scope resolution operator ,
::, followed by the function name with the appropriate
parameter list. Example: to call the area method of the
class rectangleType the statement is:
rectangleType::area()
• If the derived class does not override a public method
of the base class, you may specify a call to that public
method by using the name of the function and the
appropriate parameter list
Image Credit: thornleyfallis.com

23. Creating The Method Print Of
The Class boxType
• The class boxType has three variables: length, width, and height.
The purpose of the print method is to print the current value of
these 3 variables.
• We need to realize the following:
– The variables length and width are private members of class
rectangleType. This means that they cannot be directly accessed in
class boxType. Therefore in the boxType version of print we cannot
access these variables directly.
– The variables length and width of class rectangleType are accessible
by the class boxType only through the public methods of the class
rectangleType. This means that the print method of boxType will have
to call the print method of rectangleType to print the values of length
and width. We then print height.
Image Credit: www.nuttall-packaging.co.uk

24. Creating The Method Print Of The
Class boxType
• From the class boxType, if we want to call the
print method associated with rectangleType,
we will need to use the following statement:
rectangleType::print()
• This statement will ensure that we call the
print method associated with the class
rectangleType and not the one associated
with the class boxType.
Image Credit: www.fedex.com

25. Creating The Method Print Of The
Class boxType
• The definition of the method print for the
class boxType is:
void print ()
{
rectangleType::print();
cout << “Height = “ << height;
}
Image Credit: www.iconarchive.com

26. Creating The Method area Of
The Class boxType
• The method area of boxType calculates the surface area of a box.
• To calculate the surface area of a box we need access to the length
and width which are declared as private in class rectangleType.
• This means that we’ll have to use methods getLength and getWidth
in class rectangleType to get these values.
• Because class boxType does not have any
methods called getLenght and getWidth,
we can call these methods directly without
having to specify the base class.
Image Credit: calibermag.org

27. Creating The Method area Of
The Class boxType
• The definition of the boxType function area is:
double area();
{
return 2 * (getLength() * getWidth()
+ getLength() * height
+ getWidth() * height);
}
Image Credit: www.kauerguitars.com

28. Creating The Method volume Of
The Class boxType
• The method volume of boxType determines the volume of a box.
• One way to determine volume is to multiple the area of the base of
a box by its height.
• Use the method of the base class
rectangleType to calculate the area
of the base.
• Because the class boxType overrides the method area, to specify a
call to the method area of class rectangleType we use the name of
the base class and the scope resolution operator.
Image Credit: www.esupplystore.com

29. Creating The Method area Of
The Class boxType
• The definition of the boxType function
volume is:
double volume()
{
return rectangleType::area() * height;
}
Image Credit: movingboxestoronto.net

30. Constructors of Derived And
Base Classes
• A derived class can have it’s own private variables. This
means that a derived class needs to include its own
constructors in order to initialize them.
• When we declare a derived class object, this object
inherits the variables from the base class.
• The derived class cannot directly access the private
variables of the base class. Methods of the derived
class also cannot access these private variables.
Image Credit: www.pronto1.com

31. Constructors of Derived And
Base Classes
• What this means is that the constructors of a
derived class can directly initialize only the public
variables inherited from the base class.
• This means that when a derived object is created,
it will need to trigger the constructor of the base
class.
• The triggering of the base class’ constructor is
specified in the heading of the definition of a
derived class constructor.
Image Credit: www.itcuties.com

32. boxType Constructor
• Definition of the default constructor for
boxType:
boxType()
{
height = 0.0;
}
Image Credit: www.dreamstime.com

33. boxType Constructor With Parameters
• We first write the boxType constructor heading
including all of the parameters needed for both the
base class and the derived class constructors (i.e. all
parameters needed for rectangleType and boxType).
• In order to trigger the execution of the base class
constructor with the parameters, we add a “:” to the
heading followed by the name of the constructor of
the base class with its parameters in the heading of the
definition of the constructor of the derived class.
Image Credit: www.dreamstime.com

34. Definition of the Constructor With
Parameters of the Class boxType
boxType (double l, double, w, double h) : rectangleType(l,w)
{
if (h>=0)
height = h;
else
height = 0;
}
• In this definition we specify the constructor of rectangleType with
two parameters. When this constructor of boxType executes, it
triggers the execution of constructor of class rectangleType with
two parameters of type double.
Image Credit: www.dreamstime.com

35. Using Constructors
• Consider the following two statements:
rectangleType myRectangle (5.0,3.0);
boxType myBox (6.0, 5.0, 4.0);
• The first statement creates the rectangleType object myRectangle.
• The object myRectangle has two variables length and width.
• The second statement creates the boxType object myBox
• The object myBox has three variables length, width, and height.
Image Credit: www.jvkconstructors.com

36. 2-Part In Class Programming Challenge
• Bob’s lawn care store specializes in putting up fences around lawns
and fertilizing the lawns. Assume that yards are rectangular. In
order to put up the fence, the program needs to know the
parameter and to fertilize it needs to know the area. Write a
program that uses the class rectangleType to store the dimension
of a yard, the cost per foot to put up the fence, and the cost per
square foot to fertilize the yard. The program then outputs the cost
of putting up the fence and fertilizing the yard.
• Sue’s gift store wraps small packages. Assume that each gift is in a
box that has a length, width, and height. Write a program that uses
the class boxType to store the dimensions of a package. The user
inputs the dimensions of the package and the cost per square foot
to wrap the package. The program will then output the cost to wrap
the package. Minimum cost of wrapping a package is $1.00.
Assume: Length = 70, Width = 50, Cost of fence = $10, Cost of fertilizer = 0.25
Pkg Length = 3, Pkg width = 2, Pkg height = 0.25, Cost of wrapping = 0.25
Image Credit: www.dreamstime.com

37. The Answer!

38. What’s In Your C++ Toolbox?
cout / cin #include if/else/
Switch
Math Class String getline While
For do…While Break /
Continue
Arrays Functions