C++ Inheritance

    Inheritance is one of the important properties of Object-Oriented Programming, Inheritance allows us to inherit the properties of one class to another. Inheritance increases the concept of code-reusability, which means we need to write code once and we can use it again and again in different places of the program.

    Inheritance concepts

    When we implement the concept of inheritance in C++, we often use the terms like Base and Derived Class. Base Class: The class which properties will be inherited by Derived class; it is also known as Superclass. Derived Class: The class will inherit the property of Base Class. Let’s understand Inheritance with a real-world example, consider there is an automobile company and they create cars and trucks both car and truck are vehicles which mean their properties should be matched to the common vehicle properties, so when we create a car or truck, we inherit the properties of the vehicle. Similarly, in programming, we could require a class that shares some properties similar to the other class so instead of writing the code, again and again, we simply inherit another class properties in our new class, and this will save our time and reduce the program code.

    Need For inheritance

    • One of the main reasons for Inheritance to show the relation between models, if they shear some same properties.
    • Code reusability is also a major feature of inheritance.

    Inheritance Syntax

    class Base_Class_name
    {
    // base class properties
    };
    class Deriverd_Class_Name :visibility_mode Base_Class_Name
    {
    //derived class properties
    };

    Visibility Mode in Inheritance(access modifiers)

    There are three visibility modes private, public and protected, and the visibility mode defines which properties of the Base class can be inherited by the Derived class. Visibility modes are also known as access modifiers Visibility modes are used by the derived class.

    • public visibility mode
    • private visibility mode
    • protected visibility mode.

    public visibility mode

    If the derived class use the public visibility mode, then the drive class will be able to access the public and protected members of the base class. Using the public visibility mode, the public members of base class become the public members of derived class and the protected member of base class become the protected member of derived class. Example:

    class Base
    {  
      private:
       int a;
      public:
       int b;
      protected:
       int z;
    };
    
    class Derived : public Base  // derived class approach base class via public visibility mode
    {
     private:
      int x;
     public:
      int y;
     protected:
      int z;
    };

    private visibility mode

    In private visibility mode, the derived class can access the public and protected properties of base class privately, which mean all the public and protected members of the base class become the private members of the derived class. Example

    class Derived : private Base  // derived class approach base class via private visibility mode

    protected visibility mode

    In protected visibility mode, the derived class can access the public and protected members of the base class, which mean all the public and protected members of the base class become the protected members of the derived class.

    class Derived : protected Base  // derived class approach base class via protected visibility mode

    visibility-modes

    Visibility Mode (Access Modifiers) inherited private members of base class become derived class inherited public members of base class become derived class inherited protected members of base class become derived class
    public Cannot access private class public protected
    private Cannot access private class private private
    protected Cannot access private class protected protected

    Visibility Mode (Access Modifiers) Own class accessibility Inheritable Accessible form object outside class
    public Yes yes Yes
    private yes No No
    protected Yes Yes No

    Types of Inheritance

    The types of inheritance define which framework is followed by the derived and base class.

    • Single Inheritance
    • Multiple Inheritance
    • Hierarchical Inheritance
    • Multilevel Inheritance
    • Hybrid Inheritance

    1. Single Inheritance

    In Single Inheritance, we have a total of two classes base and derived class. Here the derived class inherit directly from the base class. Example

    #include <iostream>
    using namespace std;
    
    
    // base class
    class Mammals {
      public:
        Mammals ()
        {
          cout << "Mammals give birth" << endl;
        }
    };
    class Cat: public Mammals
      {
      };  
    
    // main function
    int main()
    {   
        // creating object of derived class will
        // invoke the constructor of base classes
        Cat tom;
        return 0;
    }

    Output

    Mammals give birth

    Behind the code In this above example, we created the object of Cat class but it invokes the constructor of Mammals class, this is because the Cat has inherited the Mammals class.

    2. Multiple inheritance:

    In Multiple Inheritance the there is one derived class and it inherits the properties of more than one base class.

    Example:
    #include <iostream>
    using namespace std;
    
    // base class
    class Mammals {
      public:
        Mammals ()   //constructor
        {
          cout << "Mammals give birth" << endl;
        }
    };
    
    class Cat
    {
      public:
        Cat()
         {
              cout<<"It's a Cat Family"<<endl;
         } 
    };
    
    class Lion: public Mammals, public Cat  //inheriting more than one base class
         {
              public:
         };
    
    // main function
    
    int main()
    {   
        // creating object of derived class will
        // invoke the constructor of base classes
        Lion king;
        return 0;
    }

    Output

    Mammals give birth
    It's a Cat Family

    Behind the Code In this example the Lion class inherit the Mammals and Cat class, and when the object of Lion class gets created the constructor of Mammals and Cat get invoked.

    3. Hierarchical inheritance

    In Hierarchical Inheritance, multiple derived class inherit from the single base class. Example

    #include <iostream>
    using namespace std;
    
    // base class
    class Mammals {
      public:
        Mammals ()   //constructor
        {
          cout << "Mammals give birth" << endl;
        }
    };
    
    class Cat: public Mammals   //inhereting Mammals Class
    {
      public:
        Cat()    //constructor
         {
             cout<<"It's a Cat "<<endl;
         } 
    
    };
    
    class Dog: public Mammals  //inheriting Mammals Class
        {
          public:
              Dog()   //constructor
                {
                   cout<<"It's a Dog "<<endl;
                }             
        };
    
    // main function
    
    int main()
    {   
        // creating object of derived class will
        // invoke the constructor of base classes
        cout<<"-----When Create a Dog Object----\n";
        Dog luffy;
        cout<<"-----When Create a cat Object----\n";
                    Cat tom;
        return 0;
    
    }

    Output

    -----When Create a Dog Object----
    Mammals give birth
    It's a Dog
    -----When Create a cat Object----
    Mammals give birth
    It's a Cat

    Behind the Code In this example both Cat and Dog class inherit the Mammals class so when the object of both the classes get created Dog luffy; and Cat tom; they also invoke the Mammals Class.

    4. Multilevel Inheritance

    In Multilevel Inheritance, the derived class become the base class for another derived class. To form a Multilevel Inheritance, we at least have three classes.

    Example:
    #include <iostream>
    using namespace std;
    // base class
    class A {
      public:
        A () //constructor
        {
          cout << "Class A has Invoked" << endl;
        }
    };
    
    class B: public A   //inheriting A Class
    {
      public:
         B()    //constructor
         {
             cout<<"Class B has Invoked "<<endl;
         } 
    };
    
    class C: public B  //inhereting B Class
      {
         public:
           C()  //constructor
             {
               cout<<"Class C has Invoked"<<endl;
             }             
     };
    
    // main function
    int main()
    {   
        // creating object of derived class
        C c;
        return 0;
    }

    Output

    Class A has Invoked
    Class B has Invoked
    Class C has Invoked

    Behind the Code In this example, we created the object of Class C and first it invoked class B and class B invoked class A, that’s why the Output of Class A show first, then Class B and at last class C.

    5. Hybrid Inheritance

    If two or more type of Inheritance type mixed together then it forms a Hybrid Inheritance. Example

    #include <iostream>
    using namespace std;
    // base class
    class A 
    {
      public:
        A ()
        {
          cout << "Class A has Invoked" << endl;
        }
    };
    class B
    {
      public:
       B()
       {
         cout<<"Class B has Invoked "<<endl;
       } 
    };
    class C: public B  //inheriting B Class
     {
         public:
           C() // constructor 
           {
             cout<<"Class C has Invoked"<<endl;
            }             
     };
    
    class D: public C, public A  //inhereting  Class C and A
        {
            public:                          
        };
    
    // main function
    int main()
    {   
        // creating object of derived class
        D d;
        return 0;
    }

    Output

    Class B has Invoked
    Class C has Invoked
    Class A has Invoked

    Inheritance Quick Summary

    • Inheritance is one of the most important properties of Object-Oriented Programming.
    • With inheritance, w can inherit the public and protected properties of one class to another.
    • The visibility mode or access modifiers define where would be the public and protected members of a base class fall inside the Derived class.
    • Private members of the class can only access the class.
    • There are three types of Access modifiers Private, Protected and Public.
    • Inheritance is divided into 5 types Single, Multiple, Hierarchical, Multilevel and hybrid.
    • Hybrid is a collection of two or more than two inheritances.

    People are also reading: