Inheritance

Inheritance in C++ means the ability of objects in one class to inherit properties of another class which implements the reusability concept. This means that it is not necessary to create a new methods and just override the existing one, if required. Saves a lot of work.
The capability of a class to derive properties and characteristics from another class is called inheritance. Inheritance is one of the most important features of Object-Oriented Programming.
Inheritance is a feature or a process in which, new classes are created from the existing classes. The new class created is called "derived class" or "child class" and the existing class is known as the "base class" or "parent class". The derived class now is said to be inherited from the base class.
When we say derived class inherits the base class, it means, the derived class inherits all the properties of the base class, without changing the properties of base class and may add new features to its own. These new features in the derived class will not affect the base class. The derived class is he specialized class for the base class.
- 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 a subclass 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 the same for all three classes. If we create these classes avoiding inheritance then we have to write all these functions in each of the three classes as shown below figure:

We can see that the above process results in duplication of the 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 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 the rest of the three classes from the base class (Vehicle).

Syntax

                
class <derived_class_name> : <access-specifier>
<base_class_name> 
{
    //body
}

Here

class - keyword to create a new class.
derived_class_name - name of the new class, which will inherit the base class.
access-specifier - either of private, public or protected. If neither is specified, PRIVATE is taken as default
base_class_name - name of the base class.
Note: A derived class doesn't inherit access to private data members. However, it does inherit a full parent object, which conatins any private members which that class declares.

Modes of inheritance

There are three modes of inheritance i.e. Public, Protected and Private.
- Public mode: In this mode of inheritance, the public members of the base class remain public in the derived class, and same goes for protected members.
- Protected mode: In this mode, the public and protected members of the base class will become protected in the derived class.
- Private class: In private mode, protected and public members of class will become private in the derived class.

                
// 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 the base class in the subclass when derived in public, protected and private modes:

Types of Inheritance

Single inheritance
Multilevel inheritance
Multiple inheritance
Hierarchical inhertance
Hybird inheritance

Single Inheritance

In single inhertance, a class is allowed to inherit from only one class. i.e. one subclass is inherited by one base class only.

Example code

                       
#include<iostream>
using namespace std;
class Beverage
{
    public : 
    void drinks()
    {
        cout << "All drinks are available" << endl;
    }
};

class Coffee : public Beverage
{
    public:
    void mocha()
    {
        cout << "Mocha tastes the best";
    }
};

int main()
{
    Coffee c;
    c.drinks();
    c.mocha(); // using sub class we are accessing member function of base class.
    return 0;
}

Multilevel Inheritance

In this type of inheritance, a derived class is created from another derived class.

Example code ↓

                       
#include <<ostream>
using namespace std;
class A
{
public:
    int x;
    A()
    {
        x = 10;
    }
};
class B : public A
{
public:
    int y;
    B()
    {
        y = 20;
    }
};
class C : public B
{
public:
    int sum;
    C()
    {
        sum = x + y;
    }
};
int main()
{
    C c_one;
    cout << "The sum is = " << c_one.sum; // by creating derived class object the constructor of parent class are called.
    return 0;
}

Multiple inheritance

Multiple inheritance is a feature of C++ where a class can inherit from more than one class. i.e. one subclass is inherited from more than one base class.

                       
#include <iostream>
using namespace std;
class A
{
public:
    int x;
    A()
    {
        x = 10;
    }
};
class B
{
public:
    int y;
    B()
    {
        y = 20;
    }
};
class C : public A, public B
{
public:
    int sum;
    C()
    {
        sum = x + y;
    }
};
int main()
{
    C c_one;
    cout << "The sum is = " << c_one.sum; 
    return 0;
}

Hierarchical inheritance

In this type of inheritance, more than one subclass 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 A
{
public:
    int x, y, z;
    A()
    {
        x = 10;
        y = 10;
        z = 10;
    }
};
class B : public A
{
public:
    int sum;
    B()
    {
        sum = x + y + z;
    }
};
class C : public A
{
public:
    int mult;
    C()
    {
        mult = x * y * z;
    }
};
int main()
{
    B b_one;
    C c_one;
    cout << "The sum is = " << b_one.sum << endl;
    cout << "The multiplication is = " << c_one.mult;
    return 0;
}

Hybrid inheritance

Hybrid inheritance is implemented by combining more than one type ofinheritance. For example: Combining Hierarchical inheritance and multiple inheritance.

                       
#include <iostream>
using namespace std;
class A
{
public:
    int x, y;
    A()
    {
        x = 10;
        y = 10;
    }
};
class B : public A
{
public:
    int sum;
    B()
    {
        sum = x + y;
    }
};
class C
{
public:
    int z;
    C()
    {
        z = 20;
    }
};
class D : public B, public C
{
public:
    int total_sum;
    D()
    {
        total_sum = sum + z;
    }
};
int main()
{
    D d_one;
    cout << "The total sum is = " << d_one.total_sum << endl;
    return 0;
}

Multipath inheritance

A derived class with two base classes and these two base classes have one common base class is called multipath inheritance. Ambiguity can arise in this type of inhertiance.
Abmiguity: A situation or statement that is unclear because it can be understood in more than one way

There are two ways to avoid this ambiguity:

Avoiding ambiguity using the scope resolution operator: Using the scope resolution operator we can manually specify the path from which data member will be accessed. See the example below ↓

                       
// C++ program demonstrating ambiguity in Multipath Inheritance
  
#include <iostream>
using namespace std;
  
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;
};
  
int main()
{
    ClassD obj;
  
    // obj.a = 10;                  // Statement 1, Error
    // obj.a = 100;                 // Statement 2, Error
  
    obj.ClassB::a = 10; // Statement 3
    obj.ClassC::a = 100; // Statement 4
  
    obj.b = 20;
    obj.c = 30;
    obj.d = 40;
  
    cout << " 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 << '\n';
}

Output ↓

                    
obj.ClassB::a = 10;
abj.ClassC:: a = 100;

In the above example, both ClassB and ClassC inherit ClassA, they both have a single copy of ClassA. However Class-D inherits both ClassB and ClassC, therefore Class-D has two copies of ClassA, one from ClassB and another from ClassC.
If we need to access the data member of ClassA through the object of Class-D, we must specify the path from which a will be accessed, whether it is from ClassB or ClassC, because compiler can’t differentiate between two copies of ClassA in Class-D.
Note: Still, there are two copies of ClassA in ClassD.

Avoiding ambiguity using the virtual base class

A virtual base class in C++ is a base class that is used to avoid the problem of multiple inheritance ambiguity. It is a base class that is declared as virtual in the inheritance hierarchy to ensure that only one instance of the shared base class is inherited by the derived classes.

                       
#include<iostream>
  
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;
};
  
int 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 << '\n';
}

Output ↓