C++ High-Frequency Interview Questions Breakdown: How Does the Virtual Function Table Work?

In C++ interviews, questions about virtual functions and polymorphism are almost always essential topics. The core of this— the virtual function table (vtable)— often leaves many people confused. Understanding its working mechanism is very helpful for mastering runtime polymorphism, optimizing performance, and even troubleshooting complex bugs.

Let’s clarify the principles, memory layout, and some practical considerations of the virtual function table.

1. Concept of the Virtual Function Table

C++ supports runtime polymorphism, meaning the same interface can be implemented with different behaviors by different objects. This relies on virtual functions:

struct Base {
    virtual void foo() { std::cout << "Base::foo\n"; }
};

struct Derived : Base {
    void foo() override { std::cout << "Derived::foo\n"; }
};

Base* b = new Derived();
b->foo(); // Outputs Derived::foo

In the code above, the pointer b points to a Derived object, but calls Derived::foo, which demonstrates runtime polymorphism. The underlying mechanism relies on the virtual function table (vtable).

In simple terms, the virtual function table is a function pointer table where each class containing virtual functions has a table that stores the addresses of those virtual functions. Each object has a hidden pointer (vptr) that points to this table.

2. Memory Layout Illustration

Assuming the following class inheritance structure:

struct Base {
    virtual void f1() { std::cout << "Base::f1\n"; }
    virtual void f2() { std::cout << "Base::f2\n"; }
};

struct Derived : Base {
    void f1() override { std::cout << "Derived::f1\n"; }
};

Base‘s virtual function table (vtable):

Function Position	Function Pointer
0	&Base::f1
1	&Base::f2

Derived‘s virtual function table:

Function Position	Function Pointer
0	&Derived::f1
1	&Base::f2

The memory layout of an object is typically:

+----------------+
| vptr -> vtable |
+----------------+
| Member Variables... |
+----------------+

Each object only needs one vptr to find the correct virtual function implementation at runtime based on the vtable.

3. Virtual Function Call Process

Taking b->foo() as an example, the actual execution process is roughly as follows:

The compiler knows that foo is a virtual function, so it generates indirect call code.
At runtime, it retrieves the virtual function table based on the object’s b‘s vptr.
It finds the corresponding function pointer in the table.
It calls the implementation pointed to by the function pointer.

This can be illustrated as:

b (Derived object)
  |
  vptr
  |
vtable (Derived)
  |--- &Derived::foo
  |--- &Base::other_virtual

4. Handling of Virtual Function Tables in Multiple Inheritance

In multiple inheritance, each base class has its own vtable, and the compiler usually stores multiple vptrs in the object’s memory. For example:

struct Base1 { virtual void f1() {} };
struct Base2 { virtual void f2() {} };

struct Derived : Base1, Base2 {
    void f1() override {}
    void f2() override {}
};

Derived object’s memory layout is roughly as follows:

+----------------+
| vptr1 -> vtable_Base1 |
+----------------+
| vptr2 -> vtable_Base2 |
+----------------+
| Member Variables... |
+----------------+

When calling f1() or f2(), it will locate the correct function based on the specific base class’s vptr.

5. Virtual Destructors and vtable

If a class has a virtual destructor, the destructor call will also be implemented through the vtable:

struct Base {
    virtual ~Base() { std::cout << "Base::~Base\n"; }
};

struct Derived : Base {
    ~Derived() { std::cout << "Derived::~Derived\n"; }
};

Base* b = new Derived();
delete b;

When deleting b, it will first call Derived::~Derived through the vptr, and then call Base::~Base, ensuring the correct order of destruction.
If the destructor is not virtual, it may lead to undefined behavior when deleting a derived class object through a base class pointer.

6. Practical Considerations

Performance Overhead

Objects will increase in size due to the vptr pointer, consuming additional space.
Virtual function calls involve one more level of indirection compared to non-virtual functions, but modern CPUs are cache-friendly, and the performance difference is usually acceptable.

Avoid Overusing Multiple Inheritance

Multiple inheritance increases the complexity of object layout, which can easily lead to ambiguity and vptr adjustments.

Optimization Techniques

If a function does not require polymorphism, avoid declaring it as a virtual function.
For frequently called functions, consider using the final specifier to allow the compiler to optimize for direct calls.

7. Debugging and Observing vtable

In actual debugging, you can print the vtable address and function pointers:

Base* b = new Derived();
auto vptr = *(void**)b;
std::cout << "vtable address: " << vptr << "\n";

Alternatively, use objdump -C -t to view the compiled symbol table and understand how the compiler generates the vtable.

8. Conclusion

The virtual function table is the core mechanism of C++ polymorphism. Understanding how vtable and vptr work helps to:

Understand the implementation of runtime polymorphism
Correctly use virtual destructors
Accurately answer related questions in interviews
Optimize object layout and performance

Spending more time understanding object memory layout and the vtable call process is very beneficial for deep usage of C++.