What is the implementation principle of C++ virtual functions

Implementation Principles of C++ Virtual Functions

Virtual functions are the core mechanism for implementing polymorphism in C++. Understanding their implementation principles is crucial for mastering C++.

Virtual Function Table (vtable)

Virtual functions are implemented through a Virtual Function Table (vtable). Each class that contains virtual functions has a corresponding vtable.

Characteristics of vtable:

• vtable is a static array storing function pointers for all virtual functions of that class
• Each object has a pointer to vtable (vptr) in memory, usually located at the beginning of the object's memory layout
• vtable is generated at compile time and stored in the program's read-only data segment

Memory Layout

Memory layout of objects containing virtual functions:

shell
+------------------+
| vptr (vtable ptr)|  Points to the class's vtable
+------------------+
| Member variable 1|
+------------------+
| Member variable 2|
+------------------+
| ...              |
+------------------+

Structure of vtable:

shell
+------------------+
| type_info pointer|  Used for RTTI (Run-Time Type Identification)
+------------------+
| Virtual function 1 pointer|
+------------------+
| Virtual function 2 pointer|
+------------------+
| ...              |
+------------------+

Virtual Function Call Process

When a virtual function is called, the compiler generates code similar to:

cpp
// Assuming call: obj->virtualFunction()
// Pseudo-code generated by compiler:
(*(obj->vptr)[index])(obj)

Call steps:

1. Find the corresponding vtable through the object's vptr
2. Find the function pointer according to the virtual function's index in the vtable
3. Call the actual function through the function pointer

vtable in Inheritance

Single inheritance:

• Derived classes inherit the base class's vtable
• Overridden virtual functions in derived classes replace corresponding function pointers in the vtable
• New virtual functions in derived classes are appended to the end of the vtable

Multiple inheritance:

• Derived classes have multiple vtables, one for each base class
• Objects have multiple vptrs, each pointing to a different vtable
• When calling virtual functions, the correct vtable must be selected based on the base class type

Pure Virtual Functions and Abstract Classes

Pure virtual functions:

cpp
class Shape {
public:
    virtual void draw() = 0;  // Pure virtual function
    virtual double area() = 0;
};

Characteristics:

• The function pointer corresponding to a pure virtual function in the vtable is nullptr
• Classes containing pure virtual functions are called abstract classes and cannot be instantiated
• Derived classes must implement all pure virtual functions to be instantiated

Virtual Destructors

Why virtual destructors are needed:

cpp
class Base {
public:
    virtual ~Base() {  // Virtual destructor
        cout << "Base destructor" << endl;
    }
};

class Derived : public Base {
public:
    ~Derived() {
        cout << "Derived destructor" << endl;
    }
};

Base* ptr = new Derived();
delete ptr;  // Correctly calls Derived and Base destructors

If not declared as virtual destructor:

• Only the base class destructor will be called, leading to resource leaks in derived classes

Performance Considerations

Overhead of virtual function calls:

• Need to access vtable indirectly through vptr
• Need to call functions indirectly through function pointers
• Breaks the possibility of inline optimization

Optimization suggestions:

• Avoid overusing virtual functions in performance-critical code
• Consider using the final keyword to prevent further overriding, which may help compiler optimization
• Use CRTP (Curiously Recurring Template Pattern) to implement static polymorphism

Code Example

cpp
#include <iostream>
using namespace std;

class Animal {
public:
    virtual void makeSound() {
        cout << "Animal makes a sound" << endl;
    }
    
    virtual ~Animal() {
        cout << "Animal destructor" << endl;
    }
};

class Dog : public Animal {
public:
    void makeSound() override {
        cout << "Dog barks" << endl;
    }
    
    ~Dog() override {
        cout << "Dog destructor" << endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() override {
        cout << "Cat meows" << endl;
    }
    
    ~Cat() override {
        cout << "Cat destructor" << endl;
    }
};

int main() {
    Animal* animals[2];
    animals[0] = new Dog();
    animals[1] = new Cat();
    
    for (int i = 0; i < 2; i++) {
        animals[i]->makeSound();  // Dynamic binding
    }
    
    for (int i = 0; i < 2; i++) {
        delete animals[i];  // Correctly calls derived class destructors
    }
    
    return 0;
}

Notes

• Virtual functions cannot be static functions
• Constructors cannot be virtual functions
• Destructors should be virtual unless it's certain they won't be used polymorphically
• Calling virtual functions in constructors and destructors does not result in dynamic binding