Inheritance

Session 5
Session Objectives
 Describe Single Inheritance
 Describe Base class and Derived class
 Access Base class members and use pointers
in classes
 Describe types of inheritance
 Describe Constructors and Destructors under
inheritance
 Describe how to call Member Functions of the
Base Class and Derived Class
 Describe Container Classes
Single Inheritance
 To maintain and reuse class objects
easily, we need to be able to relate
classes of similar nature to another.
 Single inheritance is the process of
creating new classes from an existing
base class.
 For example let us consider a program
in which we are dealing with people
employed in an organisation.
 Single Inheritance (Contd.)
Employee

Director Manager Secretary Clerk

 Each of the subclasses is considered to be

derived from the class Employee. The class
Employee is called the base class and the
newly created class is called the derived
class.
Single Inheritance (Contd.)
Class: Employee
Name, Age, Emp_id  In a class
Salary, Department hierarchy, the
derived classes
inherit the
methods and
Class: Manager variables of the
m_name, m_age,
m_Emp_id, m_salary
base class.
m_department  They can also have
perks, no_of_employees properties and
reporting methods of their
own.
 Advantages
 Most important advantage: reusability of code.
 Once a base class has been created it can be
adapted to work in different situations.
 Result of reusability of code is the development of
class libraries.
 A class library consists of data and methods
encapsulated in a class.
 Deriving a class from an existing one allows
redefining a member function of the base class
and also adding new members to the derived
class.
 The base class remains unchanged in the
process.
Base Class and Derived Class
 Derivation can be
Employee Base class represented graphically
with an arrow from the
Derived from
derived class to the base
class.
 The arrow pointing
Manager Derived class towards the base class
signifies that the derived
class refers to the
functions and data in the
base class, while the
base class has no access
to the derived class.
 Base Class and Derived Class
 Declaration of a singly derived class is similar
to that of any ordinary class.
 We also have to give the name of the base
class. For example,
class Manager : public Employee
 Any class can be used as a base class.
 A base class can be classified into two types:
 direct base
 indirect base
 Direct and Indirect Base
 A base class is called direct if it is mentioned in the
base list. For example:
class A
{ };
class B : public A
{ }; // where class A is a direct class.
 An indirect class can be written as:
class A
{ };
class B : public A
{ };
class C : public B
{ }; //Can be extended to an arbitrary number of levels.
 Accessibility
 Accessibility: Knowing when a member
function or data member of a base class can
be used by objects of the derived class.

 Class members can always be accessed by

member functions within their own class, whether
the members are private or public.

 Objects defined outside the class can access class

members only if the members are public.
 Accessing Base Class Members
 With inheritance:
 Derived class members can access members of
the base class if its members are public.
 Derived class members cannot access the private
members of the base class.
 For example, if emp1 is an instance of class Employee,
and display() is a member function of Employee,
then in main() the statement emp1.display();
is valid if display() is public.
 The object emp1 cannot access private members of the
class Employee.
Protected Access Specifier
 The protected section is like the private
section in terms of scope and access.
 Protected members can be accessed only
by members of that class.
 Protected members cannot be accessed by
objects or functions from outside the class,
such as main().
 The difference between private and
protected appears only in derived classes.
Accessing Base Class members
(Contd)

 Members of the derived class can access

public and protected members; they cannot
access the private members of the base class.
 In conformance with the object-oriented concept
of information hiding.
 No access to some of the class members.
Those members can be put in the private
section.
 Allow controlled access by providing some
protected members.
 Inheritance does not work in reverse.
Access rules for Base class members
Access Accessible Accessible Accessible
specifier from own class from derived from objects
class outside the
class
Public Yes Yes Yes
Protected Yes Yes No
Private Yes No No
Example
class Employee{ //base class
private:
int privA;
protected:
int protA;
public:
int pubA;
};
Example (Contd.)
//derived class
class Manager : public Employee{
public:
void fn()
{
int a;
a = privA; //error:not accessible
a = protA; //valid
a = pubA; //valid
}
};
Example (Contd.)
void main()
{
Employee emp; //base class object
emp.privA = 1; //error:not accessible
emp.protA = 1; //error:not accessible
emp.pubA = 1; //valid
Manager mgr; //derived class object
mgr.privA = 1; //error:not accessible
mgr.protA = 1; //error:not accessible
mgr.pubA = 1; //valid
}
 Pointers in classes
 We can use a pointer, which has been
declared to point to one class, to
actually refer to another class.
 A derive class reference can be assigned to
the base class pointer. But reverse is not true
 For example, because a Manager is an

Employee, a Manager* can be used as

an Employee*. However, an Employee*
cannot be used as a Manager*.
Example of pointers
void main()
{
Manager mgr;
Employee* emp = &mgr;
//valid:every Manager is an Employee
Employee eml;
Manager* man = &eml;
//error: not every Employee is a Manager
}
 An object of a derived class can be treated
as an object of its base class when
manipulated through pointers. However,
the opposite is not true.
Types of Inheritance
 A derived class can be declared with one of
the specifiers i.e., public, private and
protected.
 The keyword public in the class declaration of
the derived class specifies that objects of the
derived class are able to access public
member functions of the base class.
 With the keyword private in the derived class
declaration, objects of the derived class in
main() cannot even access public member
functions of the base class.
Example of inheritance types
class A{ //base class
private: int privA;
protected: int protA;
public: int pubA;
};
class B : public A{ //publicly derived class
public:
void fn(){
int a;
a = privA; //error:not accessible
a = protA; //valid
a = pubA; //valid
}
};
Example (Contd.)
class C : private A{ //privately derived class
public:
void fn()
{ int a;
a = privA; //error:not accessible
a = protA; //valid
a = pubA; //valid
}
};
void main()
{
int m;
B obj1; //object of publicly derived class
Example (Contd.)
m = obj1.privA; //error:not accessible
m = obj1.protA; //error:not accessible
m = obj1.pubA; //valid: B is publicly
//derived from class A
C obj2; //object of privately derived class
m = obj2.privA; //error:not accessible
m = obj2.protA; //error:not accessible
m = obj2.pubA; //error:not accessible:
//C is privately derived from class A
}
 If no access specifier is given while
creating
the class, private is assumed.
 Types of Inheritance (contd.)
 Functions in the derived classes can access protected
and public members in the base class.
 Objects of the derived classes outside the class or in
main() cannot access private or protected members
of the base class.
 The difference is between publicly and
privately derived classes.
 Objects of the class B, which is publicly derived
from A can access public members of the base
class.
 However, objects of the class C, which is privately
derived from A, cannot access any of the
members of the base class.
 Types of Inheritance (contd.)
 The functions in a protected derived class can
access protected and public members of the
base class. However, objects of the derived
class (in main or outside the class) cannot
access any of the members of the base class.
Base Class Public Private Protected
Members Inheritance Inheritance Inheritance

Public Public Private Protected

Protected Protected Private Protected
Private Not inherited Not inherited Not inherited
 Accessibility for Derived
classes
 There is an easy way to remember the table.
 First of all, derived classes have no access to

private members of a base class.

 Secondly, inheriting the base class publicly does

not change the access levels of the members

inherited by the derived class from the base.
 The other two access levels of the base class

cause all inherited members to be of the same

access level, as the base class (private for private
base, protected for protected base).
Multi-level inheritance
 Public, private or
protected will affect
the access the
derived class
functions have over
the members of the
base classes in a
multi-level
inheritance.
Example for multi-level
inheritance
 In the following code the class B derives privately from
class A and class C in turn derives publicly from class B.
class A{
public :
int a;
};
class B : private A{
public :
int b;
void func_b()
{ int x,y;
x=a; // valid
y=b; // valid
}
Example (Contd.)
class C : public B
{
public :
void func_c()
{int x,y;
x=a; // not valid
y=b; // valid
}
};
Constructors under inheritance
 The constructor of the base part of an object is first called, then
the appropriate constructor of the derived class is called.
class Base{
protected:
int a;
public:
Base(){a = 0;} //default constructor
Base(int c){ a = c;}//one-arg constructor
};
class Derived : public Base{
public:
Derived(): Base(){}//default constructor
Derived(int c): Base(c){}
//constructor with one-arg
Constructors (Contd.)
 When you declare an object of the
derived class, with the statement
Derived obj; it will cause the constructor of the
base class to be called first and then the
constructor of the derived class
 The base class constructor is given after
the derived class constructor, separated
by a colon, as in,
Derived(): Base(){}
Constructors (Contd.)
 Can explicitly select which constructor
of the base class should be called
during a call of the constructor of a
derived class.
Derived obj1(20); uses the one-argument
constructor in Derived. This constructor also calls
the corresponding constructor in the base class.
Derived(int c): Base(c);
//argument c is passed to Base
Destructors
 Destructors are called in the reverse order to
constructors.
 Destructors will be called for the derived class
first, then for the base class.
 A destructor for the derived class is to be defined
only if its constructor allocates any memory
through dynamic memory management.
 If the constructor of the derived class does not do
anything or no additional data members are added
in the derived class, then the destructor for the
derived class can be an empty function.
Calling Member Functions
 Member functions in a derived class can have
the same name as those in the base class.
 When the function is invoked with the object
of the base class, the function from the base
class is called.
 When you use the name of the derived class
object, the function from the derived class is
invoked.
 If a member function from the derived class
wants to call the base class function of the
same name, it must use the scope resolution
operator.
Calling Member Functions
(Contd.)

 A function in the base class can be

invoked using the objects of the base
class as well as the derived class.
 If a function exists in the derived class
and not in the base class, it can be
invoked only with the objects of the
derived class.
Calling Member Functions
(Contd.)
class Base{
protected:
int ss;
public:
int func()
{return ss;}
};
class Derived: public Base{
public:
int func()
{return Base::func();}
};
Calling Member Functions
(Contd.)
void main()
{
Base b1; //base class object
b1.func(); //calls base class func
Derived a1; //derived class object
a1.func(); //calls derived class func
}
Container classes
 Inheritance can be termed as an "is a"
relationship.
 Example of the employee: The manager is
an employee or the secretary is an
employee etc.
 In contrast, a class X that has a member of
another class Y is said to have a Y or X
contains Y. This relationship is called a
membership or a "has a" relationship.
class X{ //X contains Y
public:
Y abc;};
 Container classes (Contd.)
 When a class contains an object of another
class as its member it is called a container
class.
 Example of a jet plane: Consider deriving a class
for a jet plane from a class called engine. A jet
plane is not an engine but has an engine.
 Whether to use inheritance or membership: Ask
whether a jet plane has more than one engine. If
that is a possibility, it is most likely that the
relationship will be "has a" rather than "is a".
Constructors in container
classes
class engine{
private:
int num;
public:
engine(int s)
{num = s;}
};
class jet{
private:
int jt;
engine eobj; //declaring an object here
public:
jet(int x, int y): eobj(y)
{jt = x; }
 Constructors (Contd.)
 In the constructor of class jet the name of
the object of the class engine is written after
the colon. It tells the compiler to initialise the
eobj data member of class jet with the
value in y. Similar to declaring an object of
class engine with the statement,
engine eobj(y);

 Variables of any data type can be initialised

like this.