Advertisement

---

Top

< Prev

Next >

In our previous article, we introduced you to one of the types of inheritance - multiple inheritance. Today we are going to discuss the another type of inheritance in C++ named - multilevel inheritance. Multilevel inheritance is performed when a class inherits the features of multiple classes(one class at a time).

The class that wants to use the features of another class is called subclass or derived class, whereas the classes whose features are to be used/inherited is referred to as base classes.

What features a subclass inherits from its base class, through inheritance?

When a subclass inherits a base class, it inherits only the members of superclass that are marked with public, protected visibility modes, these members are -
• Properties of the base class.
• Functions of the base class.

Note - Base class members marked with private visibility mode are never inherited.

Syntax of Multilevel Inheritance

To understand the concept of multilevel inheritance, let us take an example. Let us say that we have a class X which is inherited by a class named Y, which is in turn inherited by another class Z and this is a scenario of multilevel inheritance where -

• Class X is the top-level-base-class which is inherited by class Y.
• Class Y is an intermediate-base-class, which is inherited by a class Z.
• Class Z is at the bottom of multilevel inheritance i.e. final-derived-class and it contains both the features inherited by class X and class Y.

Syntax of multilevel inheritance

class X
{
//members of top-level-base-class, X
}



class Y : visibility-mode X
{
//members of intermediate-base-class, Y 
}



class Z : visibility-mode Y
{
//members of final-derived-class, Z
}

• The colon : between derived-class and the names of base-class indicates that inheritance is being performed.


• The visibility-mode is used to define whether the features of base class are publicly inherited, privately inherited or protected inherited, depending on the value of visibility-mode which could be either public, private or protected.
  
  Defining visibility-mode when performing inheritance is optional, and if you don't specify it then the default visibility-mode value is private.
  
  Note : There could be multiple intermediate classes until the final derived class is achieved.

Rules of inheritance -

Depending on the value of visibility-mode, multiple inheritance can be performed in various ways -

• When a class inherits another class with the visibility-mode - public.

When a class is publicly inherited by another class, its public members become the public members of the derived class, its protected members become the protected members of the derived class, while the private members of any class cannot be inherited.



• When a class inherits another class with the visibility-mode - private.


When a class is privately inherited by another class, its public members become the private members of the derived class, its protected members become the private members of the derived class, while the private members of any class cannot be inherited.



• When a class inherits another class with the visibility-mode - protected.


When a class is inherited by another class using the protected visibility mode, its public members become the protected members of the derived class, its protected members become the protected members of the derived class, while the private members of any class cannot be inherited.

Advertisement

• Multiple Inheritance


Let us see an example of a class which publicly inherit the feature of two classes(inheriting one class at a time) by another class, by performing multilevel inheritance.



#include<iostream>

using namespace std;

//First Base class
class X
{
public: 
 int x1;
 int get_x1();


private:
 int x2;
 int get_x2();
};



//Definition of get_x1() function of X class
int X :: get_x1()
{
	return x1; 
}


//Definition of get_x2() function of X class
int X :: get_x2()
{
	return x2; 
}



//Intermediate base class, inheriting from class X
class Y : public X
{
public: 
 int y1;
 int get_y1();


protected:
 int y2;
 int get_y2();
};



//Definition of get_y1() function of Y class
int Y :: get_y1()
{
	return y1; 
}


//Definition of get_y2() function of Y class
int Y :: get_y2()
{
	return y2; 
}



//Derived class Z, publicly inheriting the class Y
class Z : public Y
{
};




int main()
{
	Z ob; 			//Making an object of derived class
	ob.x1 = 10; 		//Accessing an inherited property x1

	//ob.x2 = 10; not possible because x2 is private and cannot be inherited.

	ob.y1 = 20; 		//Accessing an inherited property y1
	//ob.y2 = 20; not possible because y2 is protected and cannot be directly accessed in the main method outside its class.

	cout<< "The value of x1 is : " << ob.x1 << "\n";
	cout<< "The value of y1 is : " << ob.y1 << "\n";

	return 0;
}





Output

The value of x1 is : 10
The value of y1 is : 20




In the example above, the class named X is the top-level-base-class and it is inherited by class Y, which in turn is inherited by class Z, which means that -
• The public and members of class X class, such as its property - x1 and its function get_x1() are inherited and have become the public members in the derived class Y.


• The public and members of class Y class, such as its property - y1 and its function get_y1() are inherited and have become the public members in the derived class Z.


• While the protected property of Y class, such as - y2 and function get_y2() have become the protected members in the derived class Z, which can only be accessed from within the functions of class Z and not from the main function defined outside the scope of class Z.


Note : The private members of a class are never inherited. Hence, the property of X and Y class such as - x2 and y2 and functions like get_x() and get_y2() are not inherited by X class and they cannot be accessed by its object, doing so will result in a compile error.






Mixing the visibility-mode


In multilevel inheritance, you could have different visibility-mode values for different classes i.e. A class X is inheriting a class Y with public visibility mode and another class Z is inheriting the class X with protected visibility-mode or it is inheriting another class with private visibility mode, for example -



• //A class X is inheriting Y with public visibility-mode
  
  class X : public Y
  {
  };





• //Derived class Z is inheriting class X with protected visibility mode
  
  class Z : protected X
  {
  };




This concludes our explanation on multilevel inheritance, in the next tutorial, we are going to discuss another type of inheritance hybrid inheritance. So, let's move to the next one.






Please share this article -






< Prev
Next >
< Multiple Inheritance in C++
Hybrid Inheritance in C++ >



Advertisement