Home

Learning Hub

Articles

Function Overriding in C++: Comprehensive Guide with Real-Life Examples

Have you ever had a situation where the behaviour of a function in a base class simply wasn’t what you needed it to be in a derived class? That’s where function overriding comes in handy in C++.

Imagine you work on some project having functions within the base class. Now, you need to adjust them to suit your derived class context, but you don’t want to change the base class itself. Well, that is what we’d be solving here with function overriding.

By the end of this article, function overriding in C++ will not only be a thing you’ll understand, but you’ll be ready to use it in your projects.

What is Function Overriding in C++?

Function overriding, in simple terms, gives us the choice of overriding how a function will behave in a derived class without having to tamper with the base class. It is one of the key players in polymorphism, which simply means that, under many constellations, a function can behave differently based on who makes the call for it.

But here’s the catch: getting function overriding right can’t always be simple. Most of the time, missing virtual keywords or a mistaken set of signatures makes things confusing and introduces bugs that could be really tough to catch. So, we are going to break it down in a super duper, simple way with code examples, along with real-life analogies.

Also Read: Class and Objects in C++

Why is Inheritance Important for Function Overriding?

Before proceeding further with function overriding, let’s just take a step back here and talk a little bit about inheritance.

Why does it matter?

Because without inheritance, function overriding would not have existed either.

Imagine inheritance, which is like passing a tradition down to your family. A base class passes down traits (or functions) to a derived class. The derived class then decides whether it wants to keep those traits as is or change them. Overriding is when we decide to change one of those inherited traits.

Suppose we have a base class called Vehicle. It has a method named start(). The way all vehicles start is pretty much the same: turn the key, and the engine comes to life. But what if I have an electric car? I don’t turn a key; I push a button.

Instead of fixing all the vehicle code, we are going to inherit from the Vehicle class and then override the start() method in the derived ElectricCar class.

Otherwise, you would have to start from scratch every time there was a change, which would amount to more code, more bugs, and more headaches. Overriding saves you from that.

Detailed Explanation of How Function Overriding Works in C++

Now, let’s get to the good stuff: how function overriding works in C++.

Here’s the bottom line: overridden functions allow a derived class to implement a version of a function that already exists in the base class. What’s important to keep in mind? The function signature must be identical. That is to say:

• Same name
• Same parameters
• Same return type

We need to mark the base class function with a virtual keyword. If not, then that function will not be overridden; it’ll be hidden, and the base class function will be executed in this case.

Now, let’s consider an example for this so that you really get the point across:

In this code:

• We have a base class Vehicle with a start() function.
• The ElectricCar class inherits from Vehicle, but we override start() to reflect how an electric car starts.
• When we call start() using the ElectricCar object, it runs the overridden version.
• The virtual keyword makes it work. Without it, the base class function would be called, which is not what we want when overriding.

Step-by-step Syntax and Implementation of Function Overriding in C++

Let us understand the syntax step-by-step so that there will be no confusion.

Declaring the base class:

• Use the virtual keyword for the function that may be overridden.
• Example: virtual void start() {}

Inherit the base class in the derived class:

• Use the public keyword to ensure that the base class functions are accessible.
• Example: class ElectricCar : public Vehicle {}

Override the base class function in the derived class:

• Use the override keyword to make sure the function is properly overridden.
• Example: void start() override {}

Finally, let’s add something: user input. We will modify the above example so that it takes user input to choose the type of vehicle and outputs the appropriate start method.

Here’s how the output works based on user input:

This example really shows just how powerful function overriding is when combined with user interaction. It lets us dynamically decide at runtime which version of a function to call depending on the object type.

Also Read: OOPs Concepts in C++

Use of Virtual Keyword and Override Keyword in Function Overriding

Here is a question: Haven’t you ever defined a derived class but realised that it’s calling the wrong function?

It happens more than we would want to believe.

The virtual keyword in C++ is a saver for this very problem.

It gives the compiler a notice, “Listen, this function of the base class is intended to be overridden.” Without it, you might inadvertently call the base class the function instead of the derived class function which will bring you some odd behaviour.

Consider virtual a sort of signpost that indicates to the program which functions to use at runtime.

Let’s look at an example so we can try it out in code:

In this code:

• virtual in the base class ensures that the function in the derived class (Dog) gets invoked, not the one in Animal.
• If you omit the virtual, the function of the base class would be run, which is not what we want.

Now, let’s talk about override. This keyword was introduced in C++11 to make life a bit easier.

We all have made mistakes in our function signatures. Maybe we misspelled something, or perhaps we changed a parameter type by mistake. Without override, C++ will not catch the mistake.

Using override, the compiler checks whether our function actually overrides a base class function. If it does, the compiler throws an error. It’s like a safety net.

In the same example above, we use override so that the function in Dog properly overrides the one in Animal.

In this way, we avoid any surprises down the road.

Sometimes, coding terms are abstract, so let’s ground the function overriding with a simple analogy.

Imagine you own a restaurant.

There’s a kind of general meal everyone orders, such as dal. Any chef can cook dal, but some may add flavour. Perhaps one spices it differently or uses a different cooking method.

In our analogy,

• Base class is the general recipe for dal.
• Class derived from base class is every chef.
• Function overriding when every chef takes that general recipe and modifies it to make it their own.

Here’s what this looks like in code:

• We have a base class Chef, that cooks simple dal.
• SpicyChef and MildChef override the function makeDal() to cook their version of the dish.

Also Read: Inheritance in C++ 

Compile-Time vs. Runtime Polymorphism in C++

Now, when we talk about polymorphism in C++, we are really talking about two different things: compile-time polymorphism and runtime polymorphism.

So, what is the big deal?

Compile-time Polymorphism

This is where the compiler already knows which function to call before the program actually runs. This is where function overloading comes in. It will make the correct choice based on the parameters you pass. Everything happens before the program runs.

Runtime Polymorphism

On the other hand, runtime polymorphism is resolved only at run time. It is with this aspect that function overriding comes into play. According to the type of object concerned in a program, at run time the program resolves which version to call of a given function.

Compile-time polymorphism is fast as everything gets sorted even before the program actually runs. However, runtime polymorphism is flexible because it lets us decide at run time.

Both are used together in C++. It depends on how you use one over the other.

Let’s try to understand it further with the help of an example below.

Compile-Time Polymorphism:

Here, the compiler knows at compile-time which version of print() to call.

Runtime Polymorphism Example:

In this example, the decision is made at runtime. According to the type of the object concerned, the program checks and calls the relevant function.

Also Read: Member Function in C++

Memory Management with C++: Virtual Destructors in Function Overriding

Managing memory in C++ is bad enough; it gets really messy when you do function overriding without care.

What happens when you use a derived class’s destructor through a pointer to a base class?

If the destructor of the base class is not declared virtual, then its derived class destructor won’t be called. This can result in the loss of resources when working with dynamically allocated resources like files, memory, network connections, etc.

That is where virtual destructors come into play.

In C++, if a class is intended to be inherited and used polymorphically, its destructor should be virtual. Doing this ensures the right destructor will be called when an object is destroyed by the destructor through a pointer that is actually a pointer to the base class.

Here’s a simple reason why this should be done:

In this example:

When we delete the Derived object through the Base pointer, both destructors are called in the proper sequence, so clean-up is correct.

Now consider what happens when the base class does not declare a virtual destructor. In that case, the derived class destructor would not be invoked, and there’s a resource leak. We can avoid these problems with just one simple keyword when using polymorphism.

Therefore, when you are implementing function overriding, it is always important to ask yourself, “Does my base class need a virtual destructor?”

Advantages and Disadvantages of Function Overriding in C++

Function overriding in C++ is a strong tool, but, like every tool, it has its pros and cons.

Advantages of Function Overriding:

• Polymorphism: It gives the option for runtime polymorphism, which allows flexible and dynamic code.
• Customisation: You can specialize an inherited behaviour of base class functions to suit a particular class.
• Code Reusability: You don’t need to write out the entire blocks of code again. You simply override the things that need a change.
• Readability: Function overriding helps to keep your code organised if you have large class hierarchies.

Limitations of Function Overriding

• Performance Overhead: Virtual functions entail a slight overhead in performance as the call to the function is resolved at run time.
• Complexity: Inheritance and overriding may lead to code that is hard to trace owing to poor structure.
• Memory Management: The memory will leak if not properly managed, for instance, by use of virtual destructors when overriding.

Conclusion

Function overloading in C++ is a great technical tool, which can enhance the flexibility of object-oriented programming. The derived classes can override and, based on their own needs, modify or extend the behaviour defined by the methods of the base classes.

The right function is called at runtime using the keyword virtual and virtual destructors prevent memory leaks while working on an inheritance. This technique supports runtime polymorphism that helps programmers in writing efficient, reusable, and maintainable code.

If developers master function overriding in C++, they can design more dynamic systems-avoiding redundancy while ensuring robust and predictable program behavior in complex class hierarchies.