Inheritance in C++

Inheritance is known as one of the most essential concepts in object-oriented programming. It permits the users to define a class on the base of another class so that it becomes very simpler for creating and maintaining of any application and reuse of the functionality of the code and also improve the implementation time.

While class creation, instead of writing entire new member functions and data members, the programmer can label that the new class should inherit the member functions of an existing class. And that existing class is known as the base class. The derived class represents the new class.

Syntax of Inheritance

We need to follow the following syntax while creating a sub-class that is inherited from the base class.

A class derived class name: access mode base class name

{

};

Where access mode is one of the access-specifier i.e. public, protected, or private. If the access-specifier is not used, then it is private by default.

A simple program illustrating inheritance implementation

// C++ program of implementation
// of Inheritance

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

// Base class

class guardian
{
          public:
          int iden_a;
};

// Sub class inheriting from Base Class(guardian)

class children : public guardian

{
          public:
          int iden_b;

};

int main()

{
           children object1;

           // An object of class child has all data members
           // and member functions of class parent

           object1.iden_a = 21;
           object1.iden_b = 25;

           cout << "Children identity is " << object1.iden_a << endl;

           cout << "Guardian id is " << object1.iden_b << endl;

           return 0;
}

OUTPUT

Children identity is 21

Guardian id is 25

Reusability concept 

The classes of the C++ language can be reused in a number of methods. In other words, once a class has been written and executed in C++, this class can be used by another programmer to reuse it according to their requirements. The most common method is to create a new class from the existing classes. This mechanism is known as inheritance. The new class is referred to as a base and the new one is known as a derived class. A derived class contains entire features of the generic base class and then integrate features specific to the derived class.


MODES OF INHERITANCE

There are three modes of inheritance known as public, private and protected. Let’s understand with the help of a simple program example that is given below:

class P 
{
public:
    int p;
protected:
    int q;
private:
    int r;
};

class Q : public P

{
    // p is public
    // q is protected
    // r is not accessible from Q
};

class R : protected P

{
    // p is protected
    // q is protected
    // r is not accessible from R
};

class S : private P  // 'private' is default for classes

{
    // p is private
    // q is private
    // r is not accessible from S
};

Types of inheritance

Single Level Inheritance

Multiple Inheritance

Hierarchical Inheritance

Multilevel Inheritance

Hybrid Inheritance


Single level Inheritance

A class is permitted to inherit features from only one class. In other words, we can say one subclass is inherited by one base class only.

single level inheritance

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

#include <iostream>
using namespace std;

// base class
class website {

public:
        website()
        {
        cout << "This is a website" << endl;
        }
};

// sub class derived from two base classes
class coding: public website{
};

// main function
int main()

{
          // creating object of sub class will
          // invoke the constructor of base classes

          coding obj;
          return 0;
}

Output

This is a website


Multiple Inheritance

A derived class with multiple base class is the concept of multiple inheritance

Multiple Inheritance

C++ program to explain explaining multiple inheritance

#include <iostream>
using namespace std;

// first base class

class website {
public:

          website()
          {
          cout << "This is a website" << endl;
          }
};

// second base class
class codingsite {

public:
          codingsite()
          {
          cout << "This is coding website" << endl;
          }
};

// sub class derived from two base classes

class tutorialsite: public website, public codingsite {

};

// main function

int main()

{
    // creating object of sub class will
    // invoke the constructor of base classes

    tutorialsite obj;
    return 0;
}

Output

This is a website

This is coding website


Multilevel Inheritance

In this there is a derived class with one base class and that base class become a derived class of another class is called Multilevel Inheritance.

multilevel inheritance

#include<iostream>
using namespace std;

// base class

class website
{
public:
            website()
            {
            cout << "This is a website" << endl;
            }
};

class codingsite: public website
{
public:
            codingsite()
            {
            cout<<"objects in codingsite are coding tutorials"<<endl;
            }
};

// sub class derived from two base classes
class tutorialsite: public codingsite{

public:
         tutorialsite()
         {
            cout<<"This site has 5 web designing tutorials"<<endl;
         }
};

// main function

int main()
{
        // creating object of sub class will
        // invoke the constructor of base classes

        tutorialsite obj;
        return 0;
}

Output

This is a website

objects in codingsite are coding tutorials

This site has 5 web designing tutorials


Hierarchical Inheritance

When there is a concept found where there are multiple derived classes with same base class is known as hierarchical inheritance.

hierarchical inheritance

#include <iostream>
using namespace std;

// base class
class website

{
public:
        website()
        {
          cout << "This is a website" << endl;
        }
};

// first sub class
class codingsite: public website

{
};

// second sub class
class tutorialsite: public website

{
};

int main()

{
      // creating object of sub class will
      // invoke the constructor of base class

       codingsite object1;
       tutorialsite object2;

       return 0;
}

Output

This is a website

This is a website


Virtual Inheritance

A derived class with two base classes and these two base classes have one common base class is called multipath or hybrid inheritance.

virtual inheritance

include <iostream>

sing namespace std;

// base class
class website

{

public:
         website()
        {
          cout << "This is a website" << endl;
        }
};

// base class
class ranking

{
      public:
      ranking()
      {
             cout<<"rank of the website\n";
      }
};

// first sub class

class codingsite: public website
{
};
// second sub class
class tutorialsite: public website, public ranking

{
      

};

// main function

int main()

{
          // creating object of sub class will
          // invoke the constructor of base class

          tutorialsite obj2;
          return 0;
}

Output

This is a website

rank of the website

Leave a Reply

avatar
  Subscribe  
Notify of