Vtables

Vtables, short for virtual method tables, are a mechanism used by many object-oriented languages to implement dynamic dispatch of virtual functions. A vtable is typically a per-class table of function pointers. Each polymorphic class has an associated vtable, and each object instance carries a hidden pointer to its class's vtable, commonly called a vptr. When a program calls a virtual function through a base-class reference or pointer, the runtime uses the object's vptr to locate the correct function pointer in the vtable and invoke the function corresponding to the object's dynamic type.

Layout and behavior commonly involve entries for all virtual functions declared in the class, including inherited ones. If a function is overridden in a derived class, the derived vtable contains a pointer to the derived function in that entry; otherwise, the base-class entry is used. Destructors may appear as entries to support deleting objects via base-class pointers. The exact layout of vtables is an implementation detail and is not standardized in languages that use this mechanism, such as C++.

Multiple inheritance can complicate vtable design. Some compilers implement multiple vtables or a single vtable with adjusted pointers to support base-class subobjects, while others maintain separate vtables per base. Depending on the language and compiler, run-time type information (RTTI) may be stored alongside vtables.

Pros and cons include fast dynamic dispatch and small overhead for non-virtual calls, balanced against increased memory usage and more complex object layouts. Some languages and optimizing compilers attempt to devirtualize calls to improve performance. The exact form of vtables is an implementation detail and not universally standardized, differing across languages and compilers.