Runtime Function Overriding using Virtual Function

Unlike other languages like Java, the function overriding in C++ can be performed at both compile time and runtime. In all the above examples, the call to the overridden function is resolved during compile time. It is also called early binding where the function call is binded to its definition during compilation.

Function overriding can also be performed at the runtime, which means that function call will be binded to its definition during runtime (also known as late binding or dynamic binding). This can be done with the help of virtual functions.

Syntax

class Base {
public:
    virtual func()
    {
        // definition
    }
};

class Derived : public Base {
public:
    func() override
    {
        // new definition
    }
};

Here, override keyword tells the compiler that the given overridden function should be declared as virtual in the parent class. It is a kind of double check as the program can compile without errors even if the function is not virtual. But then, it will be compile time polymorphism and we won’t get the desired behaviour of the function overriding.

Example of Runtime Function Overriding using Virtual Function

C++

// C++ Program to illustrate how to implement runtime
// function overriding using virtual function
#include <iostream>
using namespace std;

class Base {
public:
    // Declare the function as virtual to allow overriding
    // in derived classes
    virtual void display()
    {
        cout << "Display method of Base class" << endl;
    }

    // Virtual destructor to ensure proper cleanup of
    // derived class objects
    virtual ~Base() {}
};

class Derived : public Base {
public:
    // Override the display method
    void display() override
    {
        cout << "Display method of Derived class" << endl;
    }
};

int main()
{
    Base* basePtr;
    Derived derivedObj;

    // Point base class pointer to derived class object
    basePtr = &derivedObj;

    // Call the display function
    // This will call the display method of the Derived
    // class due to the virtual function mechanism
    basePtr->display();

    return 0;
}

Output

Display method of Derived class

Advantages of Runtime Function Overriding

The following are the main advantages of function overriding:

Methods are selected at runtime based on object type.
Common interfaces and implementations can be reused as we only need to implement the interface for base class.
Changes in base classes automatically affect derived classes.
Facilitates the implementation of design patterns different design patterns.
Client code interacts with base class interface, not specific implementations reducing the coupling.

Limitations of Runtime Function Overriding

While runtime function overriding provides numerous advantages, it also comes with certain limitations:

Virtual function calls are generally slower than non-virtual function calls due to the indirection involved in the virtual table lookup.
Implementing and maintaining polymorphic code can be more complex compared to simpler non-polymorphic code.
Virtual tables and virtual pointers add to the memory overhead, especially in large systems with many classes.
Errors related to function overriding (e.g., incorrect signatures) might only be detected at runtime, leading to potential bugs.

Function Overriding in C++

A function is a block of statements that together performs a specific task by taking some input and producing a particular output. Function overriding in C++ is termed as the redefinition of base class function in its derived class with the same signature i.e. return type and parameters. It can be of both type: Compile Time and Runtime Polymorphism.

Runtime Function Overriding using Virtual Function

Example of Runtime Function Overriding using Virtual Function

Advantages of Runtime Function Overriding

Limitations of Runtime Function Overriding

Function Overriding in C++

Similar Reads