Inheritance
Inheritance means access the properties and features of one class into another class. The class
who is going to provide its features to another class will be called base class and the class who is
using the properties and features of another class will be called derived class.
Example of inheritance
#include<iostream.h>
#include<conio.h>
class Employee
{
int Id;
char Name[25];
int Age;
long Salary;
public:
void GetData()
{
cout<<"\n\tEnter Employee Id : ";
cin>>Id;
cout<<"\n\tEnter Employee Name : ";
cin>>Name;
cout<<"\n\tEnter Employee Age : ";
cin>>Age;
cout<<"\n\tEnter Employee Salary : ";
cin>>Salary;
}
void PutData()
{
cout<<"\n\nEmployee Id : "<<Id;
cout<<"\nEmployee Name : "<<Name;
cout<<"\nEmployee Age : "<<Age;
cout<<"\nEmployee Salary : "<<Salary;
}
};
class Company : public Employee //Statement 1
{
int RegNo;
char CName[25];
public:
void ReadData()
{
cout<<"\n\nEnter Registration No. : ";
cin>>RegNo;
cout<<"\nEnter Company Name : ";
cin>>CName;
void WriteData()
{
cout<<"\n\nRegistration No. : "<<RegNo;
cout<<"\nCompany Name : "<<CName;
}
};
void main()
{
Company C; //Statement 2 : Creating Object of Derived Class
C.GetData(); //Statement 3 : Calling Base Class Method()
C.ReadData();
C.PutData(); //Statement 5 : Calling Base Class Method()
C.WriteData();
}
Output :
Enter Employee Id : 1
Enter Employee Name : Kumar
Enter Employee Age : 29
Enter Employee Salary : 45000
Enter Registration No. : 715
Enter Company Name : TutorialDost
Employee Id : 1
Employee Name : Kumar
Employee Age : 29
Employee Salary : 45000
Registration No. : 715
Company Name : TutorialDost
Consider the statement 1, we are publically inheriting an Employee class into Company class
using colon(:).Now, The object of Company class can access the member function GetData()
and PutData() of Employee class.
Derived class can inherit Base class as private, protected or public.
C++ Access Modifiers
Access modifiers defines the scope of members of BaseClass into DerivedClass.
C++ supports the followling access modifiers:
Private Modifier
Protected Modifier
Public Modifier
Private Modifier: The scope of private members are restricted to its own class. Private members
can't be accessed by the derived class or in main() function.
Protected Modifier: The scope of protected members are restricted to its own class and derived
class. Protected members can be accessed by the derived class but they can't be accessed in
main() function.
Public Modifier: Public members can be accessed by its own class, derived class and in main()
function.
Own class Derived class main()
Private
Protected
Public
Scope of base class members in derived class
Access base class as private
When a derived class inherit base class as private, protected and public members of base class
will become private members of derived class.
Access base class as protected
When a derived class inherit base class as protected, protected and public members of base class
will become protected members of derived class.
Access base class as public
When a derived class inherit base class as public, protected members of base class will become
protected members of derived class and public members of base class will become public
members of derived class.
Types of Inheritance
C++ supports six types of inheritance as follows:
Single Inheritance
Multilevel Inheritance
Multiple Inheritance
Heirarchical Inheritance
Hybrid Inheritance
Multipath Inheritance
Single Inheritance
A derived class with only one base class is called single inheritance.
Multilevel Inheritance
A derived class with one base class and that base class is a derived class of another is called
multilevel inheritance.
Multiple Inheritance
A derived class with multiple base class is called multiple inheritance.
Heirarchical Inheritance
Multiple derived classes with same base class is called hierarchical inheritance.
Hybrid Inheritance
Combination of multiple and hierarchical inheritance is called hybrid inheritance.
Multipath Inheritance
A derived class with two base classes and these two base classes have one common base class is
called multipath inheritance.
C++ Multipath Inheritance
A derived class with two base classes and these two base classes have one common base class is
called multipath inheritance.
C++ Ambiguity
Ambiguity in C++ occur when a derived class have two base classes and these two base classes
have one common base class. Consider the followling figure:
Example of, occurrence of C++ ambiguity
#include<iostream.h>
#include<conio.h>
class ClassA
{
public:
int a;
};
class ClassB : public ClassA
{
public:
int b;
};
class ClassC : public ClassA
{
public:
int c;
};
class ClassD : public ClassB, public ClassC
{
public:
int d;
};
void main()
{
ClassD obj;
//obj.a = 10; //Statement 1, Error
occur
//obj.a = 100; //Statement 2, Error
occur
obj.ClassB::a = 10; //Statement 3
obj.ClassC::a = 100; //Statement 4
obj.b = 20;
obj.c = 30;
obj.d = 40;
cout<< "\n A from ClassB : "<< obj.ClassB::a;
cout<< "\n A from ClassC : "<< obj.ClassC::a;
cout<< "\n B : "<< obj.b;
cout<< "\n C : "<< obj.c;
cout<< "\n D : "<< obj.d;
Output :
A from ClassB : 10
A from ClassC : 100
B : 20
C : 30
D : 40
In the above example, both ClassB & ClassC inherit ClassA, they both have single copy of
ClassA. However ClassD inherit both ClassB & ClassC, therefore ClassD have two copies of
ClassA, one from ClassB and another from ClassC.
If we need to access the data member a of ClassA through the object of ClassD, we must specify
the path from which a will be accessed, whether it is from ClassB or ClassC, bco'z compiler
can't differentiate between two copies of ClassA in ClassD.
There are two ways to avoid c++ ambiguity.
Using scope resolution operator
Using virtual base class
1. Avoid ambiguity using scope resolution operator
Using scope resolution operator we can manually specify the path from which data member a
will be accessed, as shown in statement 3 and 4, in the above example.
obj.ClassB::a = 10; //Statement 3
obj.ClassC::a = 100; //Statement 4
Note : still, there are two copies of ClassA in ClassD.
2. Avoid ambiguity using virtual base class
To remove multiple copies of ClassA from ClassD, we must inherit ClassA in ClassB and
ClassC as virtual class.
Example to avoid ambiguity by making base class as a virtual base class
#include<iostream.h>
#include<conio.h>
class ClassA
{
public:
int a;
};
class ClassB : virtual public ClassA
{
public:
int b;
};
class ClassC : virtual public ClassA
{
public:
int c;
};
class ClassD : public ClassB, public ClassC
{
public:
int d;
};
void main()
{
ClassD obj;
obj.a = 10; //Statement 3
obj.a = 100; //Statement 4
obj.b = 20;
obj.c = 30;
obj.d = 40;
cout<< "\n A : "<< obj.a;
cout<< "\n B : "<< obj.b;
cout<< "\n C : "<< obj.c;
cout<< "\n D : "<< obj.d;
Output :
A : 100
B : 20
C : 30
