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.

Sub Class: The class that inherits properties from another class is called Sub class
or Derived Class.

Super Class:The class whose properties are inherited by sub class is called Base
Class or Super class.

Why and when to use inheritance?

Consider a group of vehicles. You need to create classes for Bus, Car and Truck.
The methods fuelAmount(), capacity(), applyBrakes() will be same for all of the
three classes. If we create these classes avoiding inheritance then we have to write
all of these functions in each of the three classes as shown in below figure:

You can clearly see that above process results in duplication of same code 3 times.
This increases the chances of error and data redundancy. To avoid this type of
situation, inheritance is used. If we create a class Vehicle and write these three
functions in it and inherit the rest of the classes from the vehicle class, then we can
simply avoid the duplication of data and increase re-usability. Look at the below
diagram in which the three classes are inherited from vehicle class:

Using inheritance, we have to write the functions only one time instead of three
times as we have inherited rest of the three classes from base class(Vehicle).
a

class subclass_name : access_mode base_class_name

{
//body of subclass
};
Implementing inheritance in C++: For creating a sub-class which is inherited
from the base class we have to follow the below syntax.
Syntax:

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.

Note: A derived class doesn’t inherit access to private data members. However, it

does inherit a full parent object, which contains any private members which that
class declares.

When deriving a class from a base class, the base class may be inherited
through public, protected or private inheritance. The type of inheritance
is specified by the access-specifier as explained above.

We hardly use protected or private inheritance, but public inheritance is

commonly used. While using different type of inheritance, following rules
are applied −

 Public Inheritance − When deriving a class from a public base

class, public members of the base class become public members of the
derived class and protected members of the base class
become protected members of the derived class. A base
class's privatemembers are never accessible directly from a derived class, but
can be accessed through calls to the public and protected members of the
base class.

 Protected Inheritance − When deriving from a protected base

class, public and protected members of the base class
become protected members of the derived class.

 Private Inheritance − When deriving from a private base

class, public and protected members of the base class
become privatemembers of the derived class.
// C++ program to demonstrate implementation
// of Inheritance

#include <bits/stdc++.h>
using namespace std;

//Base class
class Parent
{
public:
int id_p;
};

// Sub class inheriting from Base Class(Parent)

class Child : public Parent
{
public:
int id_c;
};

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; }

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’.
 Modes of Inheritance

1. 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.

/ C++ Implementation to show that a derived class

// doesn’t inherit access to private data members. 
// However, it does inherit a full parent object
class A 
{
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
};
  
class D : private A    // 'private' is default for classes
{
    // x is private
    // y is private
    // z is not accessible from D
};

The below table summarizes the above three modes and shows the access specifier of
the members of base class in the sub class when derived in public, protected and
private modes:

Types of Inheritance in C++

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
};

// C++ program to explain // Single inheritance

#include <iostream>
using namespace std;
class Vehicle // base class
{
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;
}

1. O/P :- This is a vehicle

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 classes.

class subclass_name : access_mode base_class1, access_mode

base_class2, ....
{
//body of subclass
};

#include <iostream>
using namespace std;
  
// 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;
}

O/P:-
This is a Vehicle
This is a 4 wheeler Vehicle

In C++ programming, a class can be derived from more than one parents.
For example: A class Bat is derived from base
classes Mammal and WingedAnimal. It makes sense because bat is a
mammal as well as a winged animal
#include <iostream>
using namespace std;

class Mammal {
public:
Mammal()
{
cout << "Mammals can give direct birth." << endl;
}
};

class WingedAnimal {
public:
WingedAnimal()
{
cout << "Winged animal can flap." << endl;
}
};
class Bat: public Mammal, public WingedAnimal
{
};
int main()
{
Bat b1;
return 0;
}
Mammals can give direct birth.

Winged animal can flap.

Multilevel Inheritance: In this type of inheritance, a derived class is created from

another derived class.

In C++ programming, not only you can derive a class from the base class but you can also
derive a class from the derived class. This form of inheritance is known as multilevel
inheritance.

class A
{
... .. ...
};
class B: public A
{
... .. ...
};
class C: public B
{
... ... ...
};
#include <iostream>
using namespace std;

class A
{
public:
void display()
{
cout<<"Base class content.";
}
};

class B : public A
{

};

class C : public B
{

};

int main()
{
C obj;
obj.display();
return 0;
}
#include <iostream>
using namespace std;
  
class Vehicle  // base class
{
  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;
     }
};
int main()
{   
    //creating object of sub class will
    //invoke the constructor of base classes
    Car obj;
    return 0;
}
o/p:- This is a Vehicle
Objects with 4 wheels are vehicles
Car has 4 Wheels

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.

#include <iostream>
using namespace std;
  
class Vehicle  // base class
{
  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;
}

o/p:-
This is a Vehicle
This is a Vehicle

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:
#include <iostream>
using namespace std;
  
class Vehicle  // base class 
{
  public:
    Vehicle()
    {
      cout << "This is a Vehicle" << endl;
    }
};
  
class Fare //base class
{
    public:
    Fare()
    {
        cout<<"Fare of Vehicle\n";
    }
};
  
// first sub class 
class Car: public Vehicle
{
  
};
  
// second sub class
class Bus: public Vehicle, public Fare
{
      
};
  

// main function
int main()
{   
    // creating object of sub class will
    // invoke the constructor of base class
    Bus obj2;
    return 0;
}

Output:
This is a Vehicle
Fare of Vehicle
C++ Virtual Base Class
Virtual base class is used in situation where a derived have multiple copies of base
class. Consider the following figure:

Example without using virtual base class

#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.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;

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.

Statement 1 and 2 in above example will generate error, bco'z compiler can't
differentiate between two copies of ClassA in ClassD.

To remove multiple copies of ClassA from ClassD, we must

inherit ClassA in ClassBand ClassC as virtual 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 1

obj.a = 100; //Statement 2

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;

according to the above example, ClassD have only one copy of ClassA and statement 4 will
overwrite the value of a, given in statement 3.

Simple Program for Virtual  Base Class Example Program

#include<iostream.h>
#include<conio.h>

class student {
int rno;
public:

void getnumber() {
 cout << "Enter Roll No:";
cin>>rno;
}

void putnumber() {
cout << "\n\n\tRoll No:" << rno << "\n";
}
};

class test : virtual public student {

public:
int part1, part2;

void getmarks() {
cout << "Enter Marks\n";
cout << "Part1:";
cin>>part1;
cout << "Part2:";
cin>>part2;
}

void putmarks() {
cout << "\tMarks Obtained\n";
cout << "\n\tPart1:" << part1;
cout << "\n\tPart2:" << part2;
}
};
class sports : public virtual student {
public:
int score;

void getscore() {
cout << "Enter Sports Score:";
cin>>score;
}

void putscore() {
cout << "\n\tSports Score is:" << score;
}
};

class result : public test, public sports {

int total;
public:

void display() {
total = part1 + part2 + score;
putnumber();
putmarks();
putscore();
cout << "\n\tTotal Score:" << total;
}
};
void main() {
result obj;
 clrscr();
obj.getnumber();
obj.getmarks();
obj.getscore();
obj.display();
getch();
}
enter Roll No: 200

Enter Marks

Part1: 90
Part2: 80
Enter Sports Score: 80

Roll No: 200

Marks Obtained
Part1: 90
Part2: 80
Sports Score is: 80
Total Score is: 250
Direct Base class and Indirect Base Class
A direct base class is a base class that appears directly as a base specifier in the
declaration of its derived class. ... For a given class, all base classes that are
not direct base classes are indirect base classes.

When a derived class is declared as a base of another class, the newly derived

class inherits the properties of its base classes as well as its data and function
member also. A class is called indirect base class if it is not a direct base but is a
base class of one of the classes mentioned in the above list.

constructor in derived class

The general form of derived constructor :-
Nested Classes:-
A class may be declared as a member of another class. Consider the following:
Class M1
{
int n;
public:
int m;
};
 class M2
{
int n;
public:
int m;
};
class M3
{
M1 N1;
public:
M2 N2;
};
Now, N1 and N2 are nested classes of M3. M3 can access only public members of N1
and N2. A nested class is hidden in the lexically enclosing class.