Function Overriding

In object-oriented programming (OOP), function overriding is a key concept that allows a derived class to provide a specific implementation for a function that is already defined in its base class. This mechanism is crucial for achieving polymorphism, which enables objects of different classes to be treated as objects of a common superclass.

Understanding function overriding is essential for writing flexible and maintainable code, especially when dealing with inheritance hierarchies. In this tutorial, we will explore how to override functions using the override keyword, how to call base class functions from derived classes, and the differences between function overriding and overloading.

What is Function Overriding?

Function overriding occurs when a derived class defines a function that has the same name, return type, and parameters as a function in its base class. The primary purpose of overriding is to provide a specialized or modified implementation of the base class function in the derived class.

Real-World Analogy

Imagine you have a base class Animal with a method speak(). In this context, each animal can make a different sound. When you derive specific classes like Dog and Cat, you override the speak() method to provide unique sounds for each animal.

Using the Override Keyword

The override keyword is used in C++ to explicitly indicate that a function is intended to override a base class function. This helps catch errors at compile time if the function signature does not match any base class function.

Example 1: Basic Function Overriding

1#include <iostream>
2 
3class Animal {
4public:
5  virtual void speak() const {
6      std::cout << "Animal speaks" << std::endl;
7  }
8};
9 
10class Dog : public Animal {
11public:
12  void speak() const override {
13      std::cout << "Dog barks" << std::endl;
14  }
15};
16 
17int main() {
18  Animal* myAnimal = new Dog();
19  myAnimal->speak();  // Output: Dog barks
20  delete myAnimal;
21  return 0;
22}

In this example, the Dog class's speak() method first calls the base class Animal's speak() method using Animal::speak(), followed by its own implementation.

Overriding vs. Overloading

Function overloading and function overriding are two distinct concepts in C++:

• Overloading: A single class can have multiple functions with the same name but different parameters (different types or numbers of arguments). The function to be called is determined at compile time based on the argument types.

• Overriding: A derived class provides a specific implementation for a base class function. The function to be called is determined at runtime based on the actual object type.

Example 3: Overloading vs. Overriding

1#include <iostream>
2 
3class Animal {
4public:
5  virtual void speak() const {
6      std::cout << "Animal speaks" << std::endl;
7  }
8};
9 
10class Dog : public Animal {
11public:
12  void speak(int volume) const {  // Overloaded function
13      std::cout << "Dog barks with volume " << volume << std::endl;
14  }
15 
16  void speak() const override {  // Overridden function
17      std::cout << "Dog barks" << std::endl;
18  }
19};
20 
21int main() {
22  Animal* myAnimal = new Dog();
23  myAnimal->speak();  // Output: Dog barks
24 
25  Dog myDog;
26  myDog.speak(10);  // Output: Dog barks with volume 10
27  delete myAnimal;
28  return 0;
29}

In this example:

• The Shape class is an abstract base class with a pure virtual function area().
• The Circle and Rectangle classes override the area() method to provide specific implementations for calculating their respective areas.
• The program demonstrates polymorphism by treating different shapes as objects of type Shape.

Summary

What's Next?

In the next tutorial, we will explore virtual functions and how they enable dynamic dispatch in C++. Virtual functions are a fundamental aspect of polymorphism and allow for more flexible and powerful object-oriented designs.

Stay tuned for more insights into advanced OOP concepts!