A vtable in C is a compiler-generated mechanism that supports dynamic polymorphism by enabling virtual function calls to resolve based on the actual object type at runtime. It works by storing function pointers to the most derived version of each virtual function, and each object contains a hidden pointer (vptr) to its class’s vtable. When a virtual function is called through a base pointer or reference, the program uses the vptr to locate the correct vtable and then invokes the appropriate function. A vtable is created when a class declares or overrides a virtual function, even if it only contains pure virtual functions. Understanding vtables helps developers debug polymorphism-related issues, estimate performance overhead, and optimize code in performance-sensitive applications like game engines or embedded systems.

In C , a vtable (virtual table) is a mechanism used to support dynamic polymorphism — in simpler terms, it's how C enables virtual functions to work correctly with inheritance and object pointers or references.

When you declare a class with one or more virtual functions, the compiler creates a vtable for that class. This table holds function pointers to the most derived version of each virtual function available in the class. Each object of such a class contains a hidden pointer (vptr) to its class’s vtable. This setup allows calls to virtual functions to be resolved at runtime based on the actual object type, not the pointer/reference type.

How Does the Vtable Work?

At runtime, when you call a virtual function through a base class pointer or reference:

1. The object’s vptr is accessed.
2. From the vptr, the correct vtable is located.
3. The function pointer from the vtable corresponding to the called method is retrieved.
4. The function is invoked using that pointer.

This process ensures that even if you have a Base* pointing to a Derived object, calling a virtual function will execute the Derived version.

For example:

class Base {
public:
    virtual void show() { cout << "Base"; }
};

class Derived : public Base {
public:
    void show() override { cout << "Derived"; }
};

Base* obj = new Derived();
obj->show(); // Outputs: Derived

Here, the vtable for Derived overrides the show() entry, so the correct version runs.

What’s Inside a Vtable?

A vtable isn’t visible in your source code — it's generated automatically by the compiler. But conceptually, it looks like an array of function pointers.

Each virtual function in a class corresponds to an entry in the vtable. For classes with multiple inheritance or virtual inheritance, things get more complex — there may be multiple vtables per class to handle different base subobjects.

Some key points:

• The layout and naming of vtables are compiler-specific.
• You can't access or manipulate them directly in standard C .
• They're part of what makes virtual functions slightly slower than non-virtual ones.

When Is a Vtable Created?

A vtable is created by the compiler under these conditions:

• When a class has at least one virtual function.
• Or when it overrides a virtual function from a parent class.
• Even if all functions are pure virtual (= 0), the compiler still sets up a vtable.

Also:

• Every class with virtual functions gets its own vtable.
• Objects of such classes carry a hidden vptr, which points to their class’s vtable.

So even an empty class with a virtual destructor ends up having a vtable — and objects of that class aren't zero-sized anymore.

Why Should You Care About Vtables?

Understanding vtables helps you:

• Know what's happening under the hood when using polymorphism.
• Debug issues involving incorrect function calls or slicing.
• Estimate the memory and performance overhead of virtual functions.

For instance, if you're working in embedded systems or game engines where performance matters, knowing how virtual functions add overhead can guide optimization decisions.

That said, unless you're dealing with low-level debugging or compiler design, you generally don’t need to think about vtables directly — they just work behind the scenes.

Basically, vtables are the backbone of runtime polymorphism in C . Not something you usually touch, but good to understand when things don’t behave as expected.

The above is the detailed content of What is the vtable (virtual table) in C ?. For more information, please follow other related articles on the PHP Chinese website!