Virtual functions serve as the cornerstone of runtime polymorphism in C++. By utilizing thesse functions, developers can invoke specific behaviors defined in derived classes through base class interfaces, enabling flexible and extensible software architectures.

Core Concepts

Polymorphism allows a single interface to rerpesent different underlying data types. When a method is marked as virtual in a base class, C++ employs dynamic dispatch, determining which implementation to execute based on the actual object type during runtime rather than the pointer type at compile time.

Implementation Example

To declare a virtual function, use the virtual keyword. It is recommended to use the override specifier in derived clases to ensure that the method signature correctly matches the base implementation.

#include <iostream>

class Entity {
public:
    virtual void identify() {
        std::cout << "Generic Entity" << std::endl;
    }
};

class Robot : public Entity {
public:
    void identify() override {
        std::cout << "Robot Unit" << std::endl;
    }
};

void printIdentity(Entity* ptr) {
    ptr->identify();
}

Abstract Interfaces

Pure virtual functions are defined by assigning = 0 to the function declaration. A class containing at least one pure virtual function becomes an abstract class, which cannot be instantiated and serves purely as an interface template.

class Shape {
public:
    virtual double calculateArea() const = 0;
};

class Circle : public Shape {
    double radius;
public:
    Circle(double r) : radius(r) {}
    double calculateArea() const override { return 3.14 * radius * radius; }
};

Virtual Destructors

When managing objects via base class pointers, failing to define a virtual destructor can lead to resource leaks, as only the base destructor would execute. Declaring the base class destructor as virtual ensures the entire inheritance chain of destructors is invoked correctly upon object deletion.

class Processor {
public:
    virtual ~Processor() { std::cout << "Processor destroyed" << std::endl; }
};

class GraphicsProcessor : public Processor {
public:
    ~GraphicsProcessor() override { std::cout << "GPU destroyed" << std::endl; }
};

Internal Mechanism: The VTable

C++ implements dynamic binding through a Virtual Method Table (VTable). Every class that defines or inherits a virtual function maintains a table of function pointers. Each object instance contains a hidden pointer (vptr) that references the VTable of its specific class, allowing the runtime environment to resolve the correct function address during execution.