Virtual Function

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

​

Syntax and Mechanics

#include <iostream>

class Base {
public:
    // Virtual function declaration
    virtual void execute() const {
        std::cout << "Base execution\n";
    }

    // Virtual destructor is mandatory for polymorphic base classes
    virtual ~Base() = default; 
};

class Derived : public Base {
public:
    // Overriding the base class virtual function
    void execute() const override {
        std::cout << "Derived execution\n";
    }
};

class TerminalDerived final : public Derived {
public:
    // The final specifier prevents further overriding of this function
    void execute() const final {
        std::cout << "Terminal execution\n";
    }
};

int main() {
    Derived derivedObj;
    Base* ptr = &derivedObj; // Static type is Base*, Dynamic type is Derived*
    
    ptr->execute(); // Resolves to Derived::execute() at runtime
    
    return 0;
}

​

Under the Hood: Dynamic Dispatch (vtable and vptr)

1. vtable: At compile time, the compiler generates a static array of function pointers (the vtable) for every class that contains or inherits at least one virtual function. This table maps the virtual functions of that specific class to their concrete memory addresses.
2. vptr: The compiler injects a hidden pointer (the vptr) into the memory layout of the object instance. When an object is instantiated, its constructor initializes the vptr to point to the vtable corresponding to its class type.
3. Resolution: When a virtual function is called through a base pointer or reference, the program dereferences the object’s vptr to access the vtable, looks up the function pointer at the specific offset for that method, and invokes it. This indirection incurs a slight runtime overhead compared to standard (static) function calls.

​

Technical Constraints and Rules

• Pointer/Reference Requirement: Dynamic binding only occurs when virtual functions are accessed via pointers or references. Calling a virtual function directly on an object instance (e.g., baseObj.execute()) results in early (compile-time) binding.
• Signature Matching: To override a virtual function, the derived function must have the exact same signature (name, parameters, const qualifiers). The only exception is covariant return types, where a derived class can return a pointer or reference to a class derived from the return type of the base class function.
• Virtual Destructors: If a class contains virtual functions, its destructor must be declared virtual. If a derived object is destroyed via a base class pointer and the base class lacks a virtual destructor, the derived class’s destructor will not be called, resulting in undefined behavior and memory leaks.
• Constructors and Destructors: Constructors cannot be virtual. Furthermore, during the execution of a constructor or destructor, the dynamic type of the object is considered to be the type of the class currently being constructed or destroyed. The vptr points to the current class’s vtable. Consequently, calling a virtual function inside a constructor or destructor resolves to the current class’s implementation, not the most derived class’s implementation.
• Default Arguments: Default arguments are statically bound at compile time based on the static type of the pointer or reference, not the dynamic type. If a derived class overrides a virtual function and changes the default argument, invoking the function through a base pointer will execute the derived function but pass the base class’s default argument.

class DefaultArgBase {
public:
    virtual void print(int x = 10) { std::cout << "Base: " << x << '\n'; }
    virtual ~DefaultArgBase() = default;
};

class DefaultArgDerived : public DefaultArgBase {
public:
    void print(int x = 20) override { std::cout << "Derived: " << x << '\n'; }
};

// Usage pitfall:
// DefaultArgBase* ptr = new DefaultArgDerived();
// ptr->print(); // Outputs "Derived: 10" (Derived implementation, Base default argument)

• Static Functions: A virtual function cannot be static because static member functions do not belong to an object instance and therefore lack a this pointer (and by extension, a vptr).
• Pure Virtual Functions: Appending = 0 to a virtual function declaration makes it a pure virtual function. This forces derived classes to provide an implementation and renders the base class abstract (non-instantiable).

class AbstractBase {
public:
    virtual void pureVirtualFunction() = 0; // Pure virtual function
    virtual ~AbstractBase() = default;
};