Advertisement

---

Top

< Prev

Next >

In our previous article, we introduced you to different types of inheritance - single, multiple, multilevel inheritance. Today we are going to discuss another type of inheritance in C++ named - hybrid inheritance.

Hybrid inheritance is performed when we have to mix different types of inheritance within a single program, for example, mixing single inheritance with multiple inheritance or multilevel inheritance within a single program.

Note: The class at the topmost-level is known as base class and the class that inherit the features of a class at the topmost-level is called subclass or derived 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 and 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, 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.

The protected members cannot be directly accessed by the object of a class with a dot operator, but can only be accessed from within the function of a class.

Advertisement

• Example of Hybrid Inheritance






Let us see a coding example of above mentioned scenario of hybrid inheritance.



//C++ Example of Hybrid Inheritance


#include<iostream>
#include<string>

using namespace std;

class GrandFather
{
private:
 int height;

public:
 void set_height(int);
 int get_height();
};



//class Father is inheriting class GrandFather
class Father : public GrandFather
{
private:
string hair_color;

public:
string get_hair_color();
void set_hair_color(string);
};



class Mother
{
protected:
string eye_color;

public:
string get_eye_color();
void set_eye_color(string);
};



//Defining set_height() function of GrandFather class
void GrandFather :: set_height(int h)
{
	height = h;
}



//Defining get_height() function of GrandFather class
int GrandFather :: get_height()
{
	return height;
}



//Defining set_hair_color() function of Father class
void Father :: set_hair_color(string color)
{
	hair_color = color;
}



//Defining get_hair_color() function of Father class
string Father :: get_hair_color()
{
	return hair_color;
}



//Defining set_eye_color() function of Mother class
void Mother :: set_eye_color(string color)
{
	eye_color = color;
}



//Defining get_eye_color() function of Mother class
string Mother :: get_eye_color()
{
	return eye_color;
}




//class Son is inheriting from Father(inherited from GrandFather) and from Mother too(mix of multilevel and multiple inheritance)
class Son : public Father, public Mother
{
};



int main()
{
Son ob;
ob.set_height(175);
ob.set_hair_color("brown");
ob.set_eye_color("black");

cout<<"The color of eyes of son is : " << ob.get_eyes_color() <<"\n";
cout<<"The hair color of son is : " << ob.get_hair_color() << "\n";
cout<<"The height of son is : " << ob.get_height() <<"\n";
}





Output

The color of eyes of son is : black
The hair color of son is : brown
The height of son is : 175




In the example above, the class named GrandFather is the top-level-base-class and it is inherited by intermediate-base-class Father, which is in turn is inherited by the class Son, by performing multilevel inheritance. Besides this, the class Son also inherits another class Mother, by performing multiple inheritance (as class Son is inheriting from both Father and Mother classes at the same time), which means that -


• The private and members of class GrandFather, Father and Mother classes, such as their properties - height, eye_color, hair_color are not inherited.


• The public getters and setters functions of these three base classes are inherited and have become the public members in the derived class, Son.


• The protected member of class Mother is also inherited as protected member in the derived class, Son.


Note : The private members of a class are never inherited. But still trying to directly access these private properties, will result in a compile error.


This concludes our explanation on hybrid inheritance, in the next tutorial, we are going to discuss hierarchical inheritance.






Please share this article -






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



Advertisement