Advertisement

---

Top

< Prev

Next >

In C++, when a class is inherited, you can override the definition of any of its existing accessible methods in its subclass by a feature known as function overriding. Hence in simple words, function overriding is overriding the definition of a superclass function in its subclass.

Besides other rules that we are going to explain for function overriding, one basic rule is that a superclass function being overridden must have the same name in the subclass as well.

Use of function overriding

The key benefit to function overriding is that you can alter the behaviour of the function inherited from a superclass and define it according to need of the subclass.

A simple example of function overriding.

//C++  Example of function overriding 


#include<iostream>

using namespace std;

class A				//superclass
{
public:

void name()			//function name() in class A 
{
	cout<< "A" << "\n";
}
};

class B : public A		//subclass of A
{
public:

void name() 			//function name() of class A is overridden in class B
{
	cout<< "B" << "\n";
}
};

int main()
{
	A ob;
	ob.name();	

	B ob1;
	ob1.name(); 		//call to overridden function name() in B class
}

Output

A
B

In this example, class A is inherited by class B. The name() function of class A is returning A, but when this function is inherited and overridden by class B, it is returning B.

Rules for function overriding -:

• In order to override a function with a new function, the argument list of the overriding function must match with the argument list of function being overridden.



//C++ Argument list of the overriding function must match with the argument list of function being overridden. 


#include<iostream>

using namespace std;

class Maths
{
public:

int num1, num2;

int mathOperation(int a, int b)	//performing addition operation on two integers.
{
	num1=a;
	num2=b;
	return (num1+num2);
}
};


//Maths class is inherited by Subtract class.
class Subtract : public Maths
{
public:

int mathOperation(int a, int b)	//mathOperation is overridden to perform subtract operation on two integers.
{
	num1=a;
	num2=b;
	return (num1-num2);
}
};



int main()
{
	Subtract ob ;
	cout<< ob.mathOperation(5,2);
}





Output -:




3





Program Analysis



• Maths class is inherited by Subtract class and its function mathOperation() is overridden in Subtract class.
• While mathOperation() in class A is performing addition of two integers, mathOperation() in Subtract class is overridden to perform subtraction of two integers.

Note: The mathOperation() function in class A has two integers in its arguments, therefore, to successfully override this function in class B, mathOperation() in class B also is also defined with two integers in its arguments.




Advertisement





• The return type of an overriding function must be the same or a subtype of the return type of the function being overridden.



//C++ The return type of the overriding function must be the same or a subtype of return type of the function being overridden.


#include<iostream>

using namespace std;

class A
{
public:

A returnObject()		//function returnObject() has return type A
{
	A ob;
	cout<< "Returning an object of A" << "\n";
	return ob;
}
};


class B : public A
{
public:
B returnObject()		//overridden function returnObject() has return type B(subtype of A)
{
	B ob;
	cout<< "Returning an object of B" << "\n";
	return ob;
}
};

int main()
{
	A ob;
	ob.returnObject();

	B ob1;
	ob1.returnObject();
}





Output




Returning an object of A
Returning an object of B


Class B has extended class A and hence class B is subtype of class A. Now, the function returnObject() of class A is overridden by class B, with its return type, B i.e. subtype of A.





• The access level of an overriding function cannot be more restrictive than the access level of a function being overridden. But this access level can be less restrictive.



//C++ The access level of an overriding function cannot be more restrictive than the access level of  a function being overridden. 


#include<iostream>

using namespace std;

class A
{
public:

void showName()		//function showName() has "public" access
{
	cout<< "A";
}
};

class B : public A
{
private:

void showName()		//overridden function showName has a more restrictive "private" access
{
	cout<< "B";
}
};

int main()
{
	A a;
	a.showName();

	B b;
	b.showName();
}





Output -




A.cpp: In function 'int main()':
A.cpp:32:12: error: 'void B::showName()' is private within this context
 b.showName();
            ^
A.cpp:20:6: note: declared private here
 void showName()  //overridden function showName has a more restrictive "private
" access
      ^~~~~~~~


Class B has inherited class A and it is trying to override the showName() function it inherited from Class A. The showName() function in class A has the public access, whereas while overriding, the showName() function in class B is given the private access i.e. more restrictive, which is against the rule of overriding, hence a compile error is issued.





• Instance methods of superclass can only be overridden if they are first inherited by its subclass. Hence, private or final instance methods of a class cannot be overridden by any class, because they aren't inherited at the first place.



//C++ Instance methods of superclass can only be overridden if they are first inherited by its subclass. 


#include<iostream>

using namespace std;

class A				//superclass
{
private: 

void showMethod()		//showMethod() has private access and it cannot be overridden.
{
	cout<< "A";
}
};


class B : public A		//subclass
{
private:

void showMethod()		//creating a new function showMethod() in class B
{
	cout<< "B";
}
};



The private members of a class are never inherited by any class that extends it. Class B has extended class A and it may look like that the showMethod() function is inherited and overridden by class B but it is not. Class B has rather defined a new function with the private access and it has the same name and return type as the showMethod() function of class A.


• Data members and functions of superclass with access level such as public and protected, inherited through inheritance can be overridden.

Why function overriding is needed?

Function overriding is mainly used in a situation when we want to create a more specialized version of a generic(general) function inherited from a superclass, within the subclass.

Please share this article -

< Prev

Next >

< Function Overloading

Constructors in C++ >

Advertisement