Inheritance
BY: VAISHALI BANIYA
REFERENCE OOP BY BAL AGURUSWAMY
1
Content
Introduction to Inheritance
Why Inheritance
Implementation of Inheritance in C++
Modes of Inheritance
Types of Inheritance
2
Introduction
The capability of a class to derive properties and characteristics from another class is called
Inheritance.
Inheritance is one of the most important feature of Object Oriented Programming.
Derived Class: The class that inherits properties from another class is called Sub class or Derived
Class.
Base Class:The class whose properties are inherited by sub class is called Base Class or Super
class.
3
Why and when to use
inheritance?
4
5
Implementing Inheritance in C+
+
For creating a sub-class which is inherited from the base we have to follow Syntax: class
subclass_name : access_mode base_class_name
{
//body of subclass
};
Here, subclass_name is the name of the sub class, access_mode is the mode in which you want to
inherit this sub class for example: public, private etc. and base_class_name is the name of the base
class from which you want to inherit the sub class.
6
#include<iostream.h>
#include<conio.h>
//Base class class Parent
{
public: int id_p;
};
// Sub class inheriting from Base Class(Parent) class Child : public Parent
{
public: int id_c;
};
//main function int main() { Child obj1;
// An object of class child has all data members
// and member functions of class parent
obj1.id_c = 7;
obj1.id_p = 91;
cout << "Child id is " << obj1.id_c << endl;
cout << "Parent id is " << obj1.id_p << endl;
return 0;
}
Output: Child id is 7 Parent id is 91 In the above program the ‘Child’ class is publicly inherited
from the ‘Parent’ class so the public data members of the class ‘Parent’ will also be inherited
by the class ‘Child’.
7
Modes of Inheritance
Public mode: If we derive a sub class from a public base class. Then the public member of the
base class will become public in the derived class and protected members of the base class will
become protected in derived class.
2. Protected mode: If we derive a sub class from a Protected base class. Then both public
member and protected members of the base class will become protected in derived class.
3. Private mode: If we derive a sub class from a Private base class. Then both public member
and protected members of the base class will become Private in derived class.
Note : The private members in the base class cannot be directly accessed in the derived class,
while protected members can be directly accessed. For example, Classes B, C and D all contain
the variables x, y and z in below example. It is just question of access.
8
// C++ Implementation to show that a derived
class class D : private A // 'private' is default for classes
// doesn’t inherit access to private data members. {
// However, it does inherit a full parent object // x is private
class A // y is private
{ // z is not accessible from D
public: int x; };
protected: int y;
private: int z;
};
class B : public A
{
// x is public
// y is protected
// z is not accessible from B
};
class C : protected A
{ // x is protected //
y is protected //
z is not accessible from C
};
9
10
Types of Inheritance in C++
11
Single Inheritance
In single inheritance, a class is allowed to inherit from only one class. i.e. one sub class is
inherited by one base class only.
Syntax: class subclass_name : access_mode base_class
{
//body of subclass
};
12
#include <iostream.h>
#include<conio.h>
// base class
class Vehicle {
public:
Vehicle()
{
cout << "This is a Vehicle" << endl;
}
};
// sub class derived from two base classes
class Car: public Vehicle{
};
// main function
int main()
{
// creating object of sub class will
// invoke the constructor of base classes
Car obj;
return 0;
}
Output:
This is a vehicle
13
Multiple Inheritance
Multiple Inheritance is a feature of C++ where a class can inherit from more than one classes. i.e
one sub class is inherited from more than one base class.
Syntax: class subclass_name : access_mode base_class1,
access_mode base_class2, ....
{
//body of subclass
};
14
#include <iostream.h>
#include<conio.h>
// first base class
class Vehicle {
public:
Vehicle()
{
cout << "This is a Vehicle" << endl;
}
};
// second base class
class FourWheeler {
public:
FourWheeler()
{
cout << "This is a 4 wheeler Vehicle" << endl;
}
};
// sub class derived from two base classes
class Car: public Vehicle, public FourWheeler {
};
// main function
int main()
{
// creating object of sub class will
// invoke the constructor of base classes
Car obj;
return 0;
}
15
Multilevel Inheritance
In this type of inheritance, a derived class is created from another derived class.
16
#include <iostream.h>
#include<conio.h>
// base class
class Vehicle
{
public:
Vehicle()
{
cout << "This is a Vehicle" << endl;
}
};
class fourWheeler: public Vehicle
{ public:
fourWheeler()
{
cout<<"Objects with 4 wheels are vehicles"<<endl;
}
};
// sub class derived from two base classes
class Car: public fourWheeler{
public:
car()
{
cout<<"Car has 4 Wheels"<<endl;
}
};
// main function
int main()
{
//creating object of sub class will
//invoke the constructor of base classes
Car obj;
return 0;
}
17
Hierarchical Inheritance
In this type of inheritance, more than one sub class is inherited from a single base class. i.e.
more than one derived class is created from a single base class.
18
#include <iostream.h>
#include<conio.h>
// base class
class Vehicle
{
public:
Vehicle()
{
cout << "This is a Vehicle" << endl;
}
};
// first sub class
class Car: public Vehicle
{
};
// second sub class
class Bus: public Vehicle
{
};
// main function
int main()
{
// creating object of sub class will
// invoke the constructor of base class
Car obj1;
Bus obj2;
return 0;
}
19
Hybrid (Virtual) Inheritance
Hybrid Inheritance is implemented by combining more than one type of inheritance.
For example: Combining Hierarchical inheritance and Multiple Inheritance.
Below image shows the combination of hierarchical and multiple inheritance
20
#include <iostream.h>
#include<conio.h> // main function
// base class int main()
class Vehicle
{
{
public: // creating object of sub class will
Vehicle() // invoke the constructor of base class
{ Bus obj2;
cout << "This is a Vehicle" << endl; return 0;
} }
};
//base class
class Fare
{
public:
Fare()
{
cout<<"Fare of Vehicle\n";
}
};
// first sub class
class Car: public Vehicle
{
};
// second sub class
class Bus: public Vehicle, public Fare
{
};
21
