Advertisement

---

Top

< Prev

Next >

In our previous article, we introduced you to one of the types of inheritance in C++ i.e. single inheritance. Today we are going to discuss another type of inheritance named - multiple inheritance.

Multiple inheritance is performed when a class inherits the features of multiple classes(more than one class at a time).



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

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.

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.

Syntax of Multiple Inheritance

Let us take a look at the syntax of performing multiple inheritance, using which we could define a derived class which is inheriting multiple base classes.

class derived-class-name : visibility-mode base-class-name1, visibility-mode base-class-name2...
{
//members of derived class
}

• The derived-class-name is the name of the derived class, which is being defined and it is going to inherit features of multiple class i.e. a base classes with the name, base-class-name1, base-class-name2) and more base classes(all base classes separated by comma).


• 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.
  
  Note : Defining visibility-mode when performing inheritance is optional, and if you don't specify it then the default visibility-mode value, private, is used.

Advertisement

• Multiple Inheritance


Let us understand the syntax used to publicly inherit the feature of two classes by another class(inheriting multiple classes at the same time) by performing multiple 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; 
}



//Second Base class
class Y
{
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 two classes X and Y
class Z : public X, 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 and Y are publicly inherited by another class named 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 X.


• 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 X.


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


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 multiple inheritance, you could have different visibility-mode values for different classes that are being inherited by a single class. For example, one of the classes is inherited with public visibility mode, while another class is inherited with private visibility-mode, and another class is inherited with protected visibility mode.



• //Derived class Z is inheriting X with public visibility-mode
  //Derived class Z is also inheriting class Y with private visibility mode
  
  class Z : public X, private Y
  {
  };





• //Derived class Z is inheriting X with public visibility-mode
  //Derived class Z is also inheriting class Y with protected visibility mode
  
  class Z : public X, protected Y
  {
  };




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






Please share this article -






< Prev
Next >
< Single Inheritance in C++
Multilevel Inheritance in C++ >



Advertisement