Advertisement

---

Top

< Prev

Next >

In our previous article, we introduced you to the concept of inheritance and its various types. Today we are going to discuss the first type of inheritance in C++ named - single inheritance. Single inheritance is performed when a class inherits the features of another class.

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 base class.
• functions of base class.

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

Syntax of Single Inheritance

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

class derived-class-name : visibility-mode base-class-name
{
//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 another class i.e. a base class with the name, base-class-name.


• The colon : between derived-class-name and base-class-name 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.

Types of Single Inheritance

Depending on the value of visibility-mode, single inheritance can be performed in two ways -

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

• Single Inheritance - publicly inheriting a class


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

Let us understand the syntax used to publicly inherit the feature of a class by another class, by performing single inheritance.



#include<iostream>

using namespace std;

//Base class
class Y
{
public: 
 int a;
 int get_a();


private:
 int b;
 int get_b();
};


//Definition of get_a() function of Y class
int Y :: get_a()
{
	return a; 
}


//Definition of get_b() function of Y class
int Y :: get_b()
{
	return b; 
}


//Derived class 
class X : public Y
{
};

int main()
{
	X ob; 			//Making an object of derived class
	ob.a = 10; 		//Accessing an inherited property 'a'
	cout<<" The value in a is : " << ob.get_a(); //Accessing an inherited method 
	return 0;
} 





Output

The value in a is : 10




In the example above, the class named Y is publicly inherited by another class named X, which means that the public members of class Y class, such as its property - a and its function get_a() are inherited and have become public members in the derived class X. Hence, these inherited members are accessed by an object of derived class.

Note : The private members of a class are never inherited. Hence, the property of Y class such as - int b and its function get_b() are not inherited by X class and they cannot be accessed by its object, doing so will result in a compile error.






• Single Inheritance - privately inheriting a class


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

Let us understand the syntax used to privately inherit the feature of a class by another class, by performing single inheritance.



#include<iostream>

using namespace std;

class Y
{
public: 
 int a;
 void get_a();


private:
 int b;
 void get_b();
};


//Definition of get_a() function of Y class
void Y :: get_a()
{
	cout<<a; 
}


//Definition of get_b() function of Y class
void Y :: get_b()
{
	cout<<b;
}


class X : private Y
{
public:
 void access_a();
};


void X :: access_a()
{
a = 10;
get_a();
}

int main()
{
	X ob;
	
	//ob.a = 10;   will not work because a is private in derived class, X
	//ob.get_a();  will not work because get_a() function is private in derived class, X

	ob.access_a(); //works, because access_a() is declared public in derived class, X
	return 0;
}





Output

The value in a is : 10




In the example above, the class named Y is privately inherited by another class named X, which means that the public members of class Y class, such as its property - a and its function get_a() are inherited and have become private members in the derived class X.

Hence, these inherited members cannot be directly accessed by an object of derived class(using a dot operator) from within the main() function(defined outside the class X) and can only be accessed by calling the public function, access_a() of X class.


Note : The private members of a class are never inherited. Hence, the property of Y class such as - int b and its function get_b() are not inherited by X class and they cannot be accessed by its object, doing so will result in a compile error.





Advertisement






Single Inheritance - protected inheriting a class


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

Let us understand the syntax used to privately inherit the feature of a class by another class, by performing single inheritance.



#include<iostream>

using namespace std;

class Y
{
public: 
 int a;
 void get_a();

protected:
 int b;
 void get_b();

private:
 int c;
 void get_c();
};


//Definition of get_a() function of Y class
void Y :: get_a()
{
	cout<<"The value of a is : " << a << "\n"; 
}


//Definition of get_b() function of Y class
void Y :: get_b()
{
	cout<<"The value of b is : " << b << "\n"; 
}


//Definition of get_c() function of Y class
void Y :: get_c()
{
	cout<<c;
}


class X : protected Y
{
public:
 void access_ab();
};


void X :: access_ab()
{
a = 10;
b = 10;
get_a();
get_b();
}


int main()
{
	X ob;
	
	//ob.a = 10;   will not work because a is private in derived class, X
	//ob.b = 10;   will not work because b is protected in derived class, X

	ob.access_ab(); //works, because access_a() is declared public in derived class, X
	return 0;
}





Output

The value in a is : 10




In the example above, the class named Y is protected inherited by another class named X, which means that the public members of class Y class, such as its property - a, b and its functions get_a(), get_b() are inherited and have become protected members in the derived class X.

Hence, these inherited members cannot be directly accessed by an object of derived class(using a dot operator) from within the main() function(defined outside the class X) and can only be accessed by calling the public function, access_a() of X class.


Note : The private members of a class are never inherited. Hence, the property of Y class such as - int b and its function get_b() are not inherited by X class and they cannot be accessed by its object, doing so will result in a compile error.


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






Please share this article -






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



Advertisement