Introduction to Overriding in C++
Overriding in C++ is one of the ways to achieve run time polymorphism, in which we modify the behavior of the same method. In general, child class inherits the member functions and data members from the base class. But when our need is to override functionality in the child class, then we need to use function overriding. Overriding provides a privilege to the methods to have the same name in both base class and its derived class. It enables us to change the function behavior present in the base class, in its derived classes according to our need.
How Overriding works in C++?
Before understanding overriding, let us understand polymorphism first. The literal meaning of polymorphism is many forms i.e. having multiple forms of one particular thing. In an object-oriented programming language, this is one of the useful features. In inheritance, polymorphism is achieved, by function or method overriding, when both base and derived classes have the same declaration of member function but their definition will be different.
To do this, we need to inherit from a class into the derived class first. Then we should provide different definitions according to the need, for any one of the base class’s methods again inside the derived class. Only then, that function is said to be overridden, and this step by step process is called Function Overriding.
Let’s say take a scenario wherein our application has the requirement to change the behavior of the base class method in a derived class, then we should use the feature of overriding. In order to override a function in the derived class, we must have the same signature in child class also function names should be same in both bases and derived classes. Here signature means usage of the same data type and sequence of parameters to be passed in the function. If there is no need for parameters, then we need not use any parameter in the base function as well as child function. Below we have some points we need to keep in mind before we use overriding.
- In C++ programming, overriding will be an example of Run time polymorphism or Dynamic Polymorphism.
- Overriding is possible only in the methods present in derived classes because a method is overridden in the derived class from the base class.
- In order to achieve overriding, the functions present in base and derived classes should have the same name, same return type and same parameters.
The method which is overridden by the override declaration is called the overridden base method. The base class will contain this method. Fresh implementation called, override method is inherited from this base class. When we create an object of the derived class and call the member function which exists in both base and derived classes, the member function of the base class will be ignored and member function of the derived class will be invoked.
Below are the requirements for Method Overriding:
- The first and most important thing is Inheritance should be there from base to derived class because function overriding cannot be done within the same class. To achieve this we need a base class and a derived class.
- The redefined function should have exactly the same declaration in both base and derived classes. What does that mean? This means that the functions should have the same name, same signature and same parameter list.
Example of Overriding
Code
class Animal
{
public:
void Message ( )
{
cout << "Hello there!! I am Animal";
}
};
class Dog: public Animal
{
public:
void Message ( )
{
cout << "I am Dog!!";
}
}
4.5 (3,249 ratings)
View Course
In the above example, function Message( ) is overridden in the derived class.
Example with Steps
1. Let us take a look at the example using main( ) function in order to understand overriding better.
2. Create a base class with any name. Here I am using Animal. Write a method to display some message to display. This will be our overridden method which we will override in the inherited class. Inside the method write some message to print.
class Animal
{
public void Message( )
{
cout << "Hello there!! I am Animal";
}
}
3. Now create one more class Dog. This time we will inherit it from the base class which we created earlier i.e. Animal. To inherit we use the ‘:’ symbol.
class Dog: public Animal
4. Here we declare the same Message( ) function for different implementation and write some message. Make sure that the method name and signature in the derived class match with the method name and signature in the base class.
public void Message ( )
{
cout << "Hey!! I am Dog";
}
5. We need one more class to execute the functionality to check the overriding. Create a class with any name. Inside that write the Main function.
class ExecutionClass
{
int Main( )
{
}
}
6. Create an object of the parent class and trigger the function using the object of the class. This will invoke the Message method present in the Animal class.
Animal animalObject;
animalObject.Message( );
7. Now create the object of the derived class and call the Message method. This will invoke the Message method of the Dog class.
Dog dogObject;
dogObject.Message( );
8. What will be the output of this code? Can you guess it? This is as shown below.
Output:
9. In the above example, we are calling the function with the same name and signature, using an object created for derived and base class separately. In both cases, different versions of the function will be called for the base and derived class.
Conclusion
In this article, we understood the method overriding in C++, the need for the method overriding, real-world examples of the overriding principle, the way to achieve it and the example of overriding using the code. We can conclude that overriding is one of the useful features in polymorphism in C++ in which we can change the behavior of the base class method in the derived class.
Recommended Articles
This is a guide to Overriding in C++. Here we discuss how Overriding in C++ works, a simple example with different steps. You can also go through our other related articles to learn more-
