1
COEN 244 – PROGRAMMING METHODOLOGY II
Topic 04
Inheritance
2
Class Inheritance
• Inheritance is a mechanism that allows the
derivation of new classes from existing ones
• Class derivation is where new classes (called
derived classes) are created based on existing
classes (called base classes)
• Derived classes inherit all members of the base
class
3
Class Inheritance (cont.)
• The inherited class may add, overload, or
override functionality
• Inheritance promotes reuse by reusing the base
class and also promotes a better maintainability
and extensibility of the system
• Inheriting from derived classes is also possible,
creating inheritance hierarchies
4
Example
Person
Student Professor
GraduateStudent UndergraduateStudent FullTimeProfessor PartTimeProfessor
5
Example (cont.)
• The classes Student and Professor inherit all attributes
of the class Person
– They can also define their own attributes
• Classes GraduateStudent and UndergraduateStudent
inherit all attributes of Person and Student
– Same applies to FullTimeProfessor and
PartTimeProfessor
6
Inheritance in C++
• To specify that a class inherits from another class in
C++, you need to use the following syntax
class <base_class> {
...
};
class <derived_class> : <access_specifier> <base_class> {
...
};
• Access specifier: public, private, or protected
• For now, we use public only
7
Base Class: Student
• Assume we have the following Student class
class Student { // base class
public:
Student(int, string, string); // constructor
...
private:
string fname;
string lname;
int id;
};
• Assume: later we need to implement a
UndergradStudent class
8
Derived Class: UndergradStudent
class UndergradStudent : public Student { // derived class
public:
UndergradStudent (int, string, string); //Constructor
void setGrade( float, float, float );
private:
float assignment;
float midterm;
float final;
};
• Note:
– The attributes fname, lname and id are inherited from
the class Student
– Each class has its own constructor
9
Initializing base class members
using a member initialization list
• It is recommended to initialize data members of a
base class using a member initialization list
• Example
class UndergradStudent : public Student // derived class
{
public:
UndergradStudent (int, string, string); //Constructor
void setGrade( float, float, float );
private:
float assignment;
float midterm;
float final;
};
10
UndergradStudent (int id1, string fname1, string lname1): Student(id1,
fname1, lname1) {
assignment = 0.0;
midterm = 0.0;
final = 0.0;
}
• The constructor of UndergradStudent calls the constructor of Student
with a member initializer and after that initializes assignment, midterm,
and final
• Let’s see the full program, which is on Moodle.
11
Access modifier: Protected
• The protected member access specifier gives
intermediate access
• A protected member can be accessed
– by members of its class and
– the derived classes of the class that defines it
• To define a member as protected, use the keyword
protected
• Example is on Moodle.
12
The is-a rule
• Inheritance must satisfy the is-a rule
– A derived class is a special case of the base class
• Examples:
– A student is a person
– A professor is a person
– An undergraduate student is a student, which is a person
– A rectangle is a shape
– A car is a vehicle
13
Constructors and destructors in
inheritance
• When an object of a derived class is created the base
constructor is called first, then the derived class
constructor
• When that object is destroyed the destructors are
called in the reverse order
– The destructor of the derived class is called first and then the
destructor of the base class
• The constructors and destructors are not inherited
14
Note about derived class objects
• A derived class object can be assigned to any of its public base
class objects:
class Base {
...
private:
int x,y;
};
class Derived : public Base
{
...
private:
int z;
};
Base b; // x and y are set
Derived d; // x, y, and z are set
b = d; // fill the fields of b with the corresponding values in d
15
The order of construction
• To create a derived class object:
1. The base part is first allocated,
2. The base class constructor is called,
3. The derived part is allocated,
4. The derived class constructor body is executed
• The above procedure is implemented
recursively in a hierarchy
16
What about the destructors?
• When a derived class object is being
destroyed:
– The derived destructor is executed first;
– The base destructor is called
• Always make sure that your destructors are
well defined
17
Types of Inheritance
• There exist three types of access specifiers
with inheritance:
– public: class Derived : public Base { ... };
– protected: class Derived : protected Base { ... };
– private: class Derived : private Base { ... };
• They determine different access levels of
data members of a base class from derived
classes
18
Types of Inheritance (cont.)
• Public inheritance:
– The public members of the base class become public
members of the derived class
– The protected members of the base class become
protected members of the derived class
– The private members stay private
– This type is the most used one
• Protected inheritance:
– The public and protected members of the base class
become protected members of the derived class
– The private members stay private
19
Types of Inheritance (cont.)
• Private inheritance:
– The public and protected members of the base class
become private members of the derived class
– Private members of the base class stay private
20
Function Overriding
• The derived class can redefine the inherited member
functions
– This is known as function overriding
• Do not confuse this with function overloading
– Which can be applied whether there is inheritance or not
• Function overriding is a good way to make a base class
member function specific to the derived class that
overrides it
21
How does it work?
• The derived class redefines a member function
with the same signature (number and type of
parameters) as the base class member function to
override
• Member function overriding is used only with
inheritance
• The scope resolution operator (::) may be used in
the derived class to access the base class
overridden member function
22
Example
class Employee {
public:
Employee(string, string);
void print() const;
protected:
string fname;
string lname;
};
Employee::Employee( string fname1, string lname1) {
fname = fname1
lname = lname1;
}
23
void Employee::print() const {
cout << fname << “ ” << lname << endl;
}
24
class HourlyWorker : public Employee {
public:
HourlyWorker(string, string, double, double);
double getPay() const;
void print() const;
private:
double wage;
double hours;
};
// constructor
HourlyWorker::HourlyWorker(string pf, string pl, double w, double h)
: Employee( pf, pl ) {
wage = w;
hours = h;
}
double HourlyWorker::getPay() const {
return wage*hours;
}
25
// Overridden print function
void HourlyWorker::print() const {
Employee::print(); // Print Employee name
cout << ":" << getPay() << endl;
Example of using Employee and HourlyEmployee
Employee e1(‘‘John’’, ‘‘Young’’);
e1.print(); // print() of class Employee is called
HourlyWorker h1(‘‘Frank’’, ‘‘User’’, 150, 500);
h1.print(); // print() of HourlyWorker is called
26
Multiple inheritance
• Single inheritance: one base class as a parent
class in the inheritance hierarchy
• Multiple inheritance: a derived class has more
than one base class )
– There is no limit on the number of base classes in multiple
inheritance
– Access rules and mode of derivations for multiple inheritance
are the same as for single inheritance
– A derived class inherits all data and method members of all
bases
27
Example of multiple inheritance
Professor
Student FullTimeProfessor PartTimeProfessor
UndergraduateStudent GraduateStudent
28
Problems with multiple inheritance
• Multiple inheritance is considered as a bad design
• Do not used it unless it is really necessary!
• Alternative to multiple inheritance:
– if you need to design a class that provides to its client
the union of services provided by other classes
– try first composition, then composition with inheritance,
and lastly multiple inheritance
