How Do Virtual Method Tables (vtables) Work?
Learn how vtables enable runtime polymorphism — per-class function pointer tables, per-instance vptr, and dynamic dispatch — with a Java example.
Expected Interview Answer
A virtual method table (vtable) is a per-class array of function pointers that the runtime consults through a hidden pointer stored in each object, allowing a call through a base-type reference to dispatch to the correct overriding implementation at runtime.
When a class declares virtual functions, the compiler builds one vtable per class containing a pointer to the most-derived implementation of each virtual function in a fixed slot order. Every instance of that class carries a hidden vptr (in C++) set by the constructor to point at its class’s vtable; in Java and C#, the object’s internal class/method-table pointer plays the same role implicitly via the JVM/CLR. A virtual call compiles to two indirections: read the object’s vptr, then read the function pointer at the fixed slot for that method and jump to it — this is dynamic dispatch. A subclass that overrides a method simply writes a new pointer into the same slot in its own vtable, and unmodified inherited methods keep pointing at the parent’s implementation, which is why overriding one method never disturbs the others.
- Explains why polymorphic calls have a small, constant runtime cost
- Clarifies why non-virtual/static/private methods skip dispatch entirely
- Shows why constructors cannot fully dispatch virtually (vptr not yet finalized)
- Underpins why slicing and multiple inheritance complicate vtable layout
AI Mentor Explanation
Every franchise in a league keeps an internal “duties sheet” listing who currently holds each specialist role — new-ball bowler, death-over specialist, wicketkeeper — and the sheet is looked up fresh before each match rather than assumed from the roster printed at the season start. When a team promotes a different bowler into the death-overs slot, only that one line on the sheet changes; every other assigned role stays exactly where it was. A vtable is this per-team duties sheet: each class keeps one, listing a fixed slot per virtual method, and overriding a method just rewrites that one slot with the subclass's bowler.
Step-by-Step Explanation
Step 1
One vtable per class
The compiler builds a single array of function pointers per class that declares or inherits virtual methods, in a fixed slot order shared across the hierarchy.
Step 2
Every instance stores a vptr
The constructor sets a hidden pointer on the object to its class's vtable, so each object always knows which table to consult.
Step 3
A call reads the slot at runtime
A virtual call follows the object's vptr, indexes the fixed slot for that method, and jumps to whatever pointer sits there — this is dynamic dispatch.
Step 4
Overriding rewrites one slot
A subclass that overrides a method writes its own function pointer into that same slot in its own vtable; inherited, non-overridden slots still point at the parent implementation.
What Interviewer Expects
- A correct mental model: per-class table, per-instance pointer to it
- Understanding that a virtual call costs two indirections, not zero
- Awareness that static, private, and final/non-virtual methods bypass the vtable entirely
- Some awareness of complications: multiple inheritance (multiple vtables), object slicing, and virtual calls inside constructors
Common Mistakes
- Claiming every method call in C++/Java goes through a vtable (non-virtual and static calls do not)
- Believing the vtable is stored per-object rather than per-class (only the pointer to it is per-object)
- Assuming a virtual call made from inside a base constructor dispatches to the derived override
- Forgetting that overriding one method leaves the rest of the inherited vtable slots untouched
Best Answer (HR Friendly)
“A vtable is basically a lookup table each class keeps, listing which actual function should run for each of its overridable methods. Every object carries a hidden pointer to its class’s table, so when you call a method through a base-type reference, the program follows that pointer, looks up the right function for the object’s real type, and runs it. That’s how a Dog object called through an Animal reference still barks instead of making a generic sound.”
Code Example
class Animal {
void speak() { System.out.println("Animal sound"); }
void breathe() { System.out.println("Animal breathes"); }
}
class Dog extends Animal {
@Override
void speak() { System.out.println("Woof"); } // overrides one slot
// breathe() not overridden: inherited slot still points at Animal’s impl
}
Animal ref = new Dog();
ref.speak(); // JVM’s internal method table resolves to Dog.speak() -> "Woof"
ref.breathe(); // resolves to inherited Animal.breathe() -> "Animal breathes"Follow-up Questions
- Why can a virtual call made from inside a base class constructor not reach a derived override?
- How does multiple inheritance in C++ complicate a single vtable-per-class model?
- Why do static and private methods not participate in virtual dispatch?
- What is object slicing and how does it relate to a lost vptr?
MCQ Practice
1. A vtable is best described as?
There is one vtable per class; each instance stores a pointer (vptr) to its class's vtable for runtime dispatch.
2. When a subclass overrides exactly one virtual method, what happens to the other inherited slots?
Only the overridden slot is rewritten; every other slot in the subclass's vtable continues pointing at the inherited parent implementation.
3. Which kind of method call typically bypasses the vtable and is resolved at compile time?
Static methods are not part of the vtable mechanism — they are resolved statically at compile time, not dispatched dynamically.
Flash Cards
Vtable in one line? — A per-class array of function pointers used to resolve virtual method calls at runtime.
What does each object store? — A hidden pointer (vptr) to its class's vtable, set by the constructor.
Cost of a virtual call? — Two indirections: read the vptr, then read the function pointer at the fixed slot.
What happens when overriding one method? — Only that method's slot is rewritten; other inherited slots keep pointing at the parent implementation.