Advertisement

---

Top

< Prev

Next >

In our previous article, we have introduced you to one of the types of inheritance in C++ i.e. multilevel inheritance. Moving on, we are going to discuss another type of inheritance i.e. hierarchical inheritance.

Hierarchical inheritance is performed to replicate a hierarchical structure in a computer program, for example, when the features of a class at the topmost-level are shared by many classes at the lower level in a hierarchy through inheritance.

The class at the topmost-level is known as base class and the classes that inherit the features of the class at the topmost-level are called subclasses or derived classes.

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

When a subclass inherits a base class, it inherits only those members of the base class that are marked with public and protected visibility-mode, 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 -

Before introducting the syntax of hierarchical inheritance, let's refresh the importance concepts 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 are never 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 are never inherited.

Syntax of Hierarchical Inheritance

To understand the concept of hierarchical inheritance, let us take an example which replicates a hierarchical structure to a computer program, where:

• Class Sports is a top-level-base-class which is inherited by the classes at a lower level, named Football, Hockey and Cricket.
• Class Football, which is itself a derived class, is inherited by two classes at a lower level, named JuniorFootballTeam and SeniorFootballTeam.

Syntax of hierarchical inheritance

//C++ Hierarchical Inheritance 


class Sports
{
//members of a top-level-base-class i.e. Sports
}



class Football : visibility-mode Sports
{
//members of a derived-class at a lower level i.e. Football 
}



class Hockey : visibility-mode Sports
{
//members of another derived-class at a lower level i.e. Hockey
}



class Cricket : visibility-mode Sports
{
//members of another derived-class at a lower level i.e. Cricket
}


class JrFootballTeam : visibility-mode Football
{
//members of another derived-class at a lower level than class Football
}


class SrFootballTeam : visibility-mode Football
{
//members of another derived-class at a lower level than class Football
}

• 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 is private.

Advertisement

• Example of Hierarchical Inheritance


Let us see a coding example of the last mentioned syntax example of the hierarchical inheritance.



//C++ Example of Hierarchical Inheritance 


#include<iostream>
#include<string>

using namespace std;


//First Base class
class Sports
{
private: 
 int total_players;
 string coach_name;
 
protected:
 string captain_name;


public:
 //Getters
 int get_total_players();
 string get_coach_name();
 string get_captain_name(); 
 
 //Setters
 void set_total_players(int);
 void set_coach_name(string);
 void set_captain_name(string);
};



//Definition of get_total_players() function of Sports class
int Sports :: get_total_players()
{
	return total_players;
}



//Definition of get_coach_name() function of Sports class
string Sports :: get_coach_name()
{
	return coach_name; 
}



//Definition of get_captain_name() function of Sports class
string Sports :: get_captain_name()
{
      return captain_name;
}





//Definition of set_coach_name() function of Sports class
void Sports :: set_coach_name(string cn)
{
	coach_name = cn;
}



//Definition of set_captain_name() function of Sports class
void Sports :: set_captain_name(string cn)
{
	captain_name = cn;
}




//Definition of set_total_players() function of Sports class
void Sports :: set_total_players(int num)
{
	total_players = num; 
}




//A derived class Hockey, publicly inheriting the class Sports
class Hockey : public Sports
{
};



//A derived class Cricket, publicly inheriting the class Sports
class Cricket : public Sports
{
};



//A derived class Football, publicly inheriting from class Sports
class Football : public Sports
{
};



//A derived class JuniorFootballTeam, publicly inheriting from class Football
class JrFootballTeam : public Football
{
};



//A derived class SeniorFootballTeam, publicly inheriting from class Football
class SrFootballTeam : public Sports
{
};



int main()
{
	JrFootballTeam  ob; 		//Making an object of derived class, Football
	ob.set_captain_name("Superman");//Setting an inherited property captain_name
	ob.set_coach_name("Motivator");	//Setting an inherited property coach_name
	ob.set_total_players(11);	//Setting an inherited property total_players

	//ob.captain_name="Superman; is not possible because captain_name is private and cannot be inherited.


	cout<< "The name of captain is : " << ob.get_captain_name() << "\n";
	cout<< "The name of coach is : " << ob.get_coach_name() << "\n";
	cout<< "The total number of players are : " << ob.get_total_players() << "\n";

	return 0;
}





Output

The name of captain is : Superman
The name of coach is : Motivator
The total number of players are : 11




In the example above, the class named Sports is the top-level-base-class and it is inherited by some lower-level classes in the hierarchy, such as Football, Cricket, Hockey, which means that:


• The private members of class Sports class, such as its property - captain_name, coach_name, total_players, total_staff are not inherited.


• The public getters and setters functions, such as - get_captain_name(), set_captain_name() etc are inherited and have become the public members in all the derived class.


• A protected member of class Sports is also inherited as a protected member in the lower-level derived classes.


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


This concludes our explanation on hierarchical inheritance, in the next tutorial, we are going to discuss polymorphism in C++. So, see you there!






Please share this article -






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



Advertisement