In C++, a virtual function is a member function of a base class that can be overridden in a derived class. It enables dynamic polymorphism, allowing different objects to be treated as objects of the base class while invoking the appropriate derived class implementation of the function.
To declare a virtual function, you need to use the virtual keyword in the function declaration within the base class. For example:
class Base {
public:
virtual void someFunction() {
// Base class implementation
}
};
Here, someFunction() is declared as a virtual function in the Base class.
When a virtual function is overridden in a derived class, you use the override keyword to indicate that you are intentionally overriding the base class function. It helps catch errors at compile-time if the function signatures don’t match correctly. Here’s an example of a derived class overriding the virtual function:
class Derived : public Base {
public:
void someFunction() override {
// Derived class implementation
}
};
In the derived class, someFunction() is declared with the override keyword, indicating that it is meant to override the virtual function in the base class.
When you have a pointer or reference to an object of the base class, and you call a virtual function through that pointer or reference, the appropriate derived class implementation of the function is executed at runtime. This is known as dynamic dispatch or late binding.
Base* objPtr = new Derived();
objPtr->someFunction(); // Calls the derived class implementation
In this example, even though the pointer objPtr is of type Base*, the someFunction() call will invoke the derived class implementation because it is marked as virtual.
it call’s always most derived version of the function.
Virtual functions provide a powerful mechanism in C++ for achieving polymorphism, allowing you to write code that can work with objects of different derived classes through a common base class interface.