Die Tabelle virtueller Methoden (englisch virtual method table oder virtual function table, kurz VMT, VFT, vtbl oder vtable) ist ein Ansatz von Compilern objektorientierter Programmiersprachen, um dynamisches Binden umzusetzen. Das ist unter anderem Grundvoraussetzung für Vererbung und Polymorphie. Eine Tabelle virtueller Methoden ist eine Datenstruktur, die Methoden auf konkrete Realisierungen (Implementierung dieser Methode) abbildet. Anstatt die Realisierungen direkt anzusprechen, werden sie mit Hilfe der Tabelle indirekt adressiert.
Jeder Klasse ist eine Tabelle zugeordnet, die den virtuellen Methoden die Adresse der entsprechenden Implementierung zuordnet. In den Sprachen Java, Smalltalk und Python sind dies alle Methoden einer Klasse, in C++, den .NET-Sprachen[A 1] und Object Pascal nur die als „virtuell“ gekennzeichneten. Jedes Objekt besitzt einen versteckten Zeiger auf die Tabelle der Klasse, nach deren Vorgabe es erzeugt wurde.
Der Aufruf einer nicht-virtuellen Methode wird vom Compiler durch den direkten Aufruf der Implementierung übersetzt. Diese wird anhand des beim Aufruf angenommenen Typs des Objektes ermittelt. Tritt demnach ein polymorphes Objekt in der Gestalt eines seiner Vorfahren auf, so hat es den Typ des Vorfahren und es wird somit dessen Implementierung genutzt.
Wird stattdessen eine virtuelle Methode aufgerufen, so übersetzt der Compiler dies in einen indirekten Aufruf der in der Tabelle adressierten Implementierung. Diese hängt nicht von dem in der Referenz auf das Objekt angenommenen Typ des Objektes ab, sondern jeweils vom ursprünglichen Typ des Objektes selbst.
Implementierung der Klassen in C++:
class Hund
{
private:
string name_;
public:
Hund (string name) : name_(name) {}
virtual ~Hund() {};
virtual void sitz() const =0;
virtual void gibLaut() const {cout << "wuff" << endl;}
virtual void getName() const {cout << name_ << endl;}
};
class Dackel: public Hund
{
public:
Dackel (string name) : Hund(name) {}
void sitz() const {cout << "platz" << endl;}
void gibLaut() const {cout << "wau" << endl;}
};
Ergibt folgende VFT, gewonnen mit:
g++ -fdump-class-hierarchy hund.cpp
Vtable for Hund
Hund::_ZTV4Hund: 7u entries
0 (int (*)(...))0
8 (int (*)(...))(& _ZTI4Hund)
16 Hund::~Hund
24 Hund::~Hund
32 __cxa_pure_virtual
40 Hund::gibLaut
48 Hund::getName
Vtable for Dackel
Dackel::_ZTV6Dackel: 7u entries
0 (int (*)(...))0
8 (int (*)(...))(& _ZTI6Dackel)
16 Dackel::~Dackel
24 Dackel::~Dackel
32 Dackel::sitz
40 Dackel::gibLaut
48 Hund::getName
Verwendet werden kann das dann, indem man Funktionen oder Methoden schreibt, die allgemein für einen Hund implementiert sind.
void belle(const Hund &h)
{
h.sitz();
h.gibLaut();
}
Übergeben werden kann dann aber ein Dackel oder eine beliebige andere Hunderasse, die vielleicht später hinzugefügt wird:
int main()
{
Dackel d("Bello");
belle (d);
return 0;
}
Das Beispiel soll das Konzept zeigen: An der Verwendungsstelle soll/darf zur Kompilierzeit die konkrete Ausprägung eines Objektes nicht bekannt sein. Das Objekt ist über den Typ einer Basisklasse bekannt. Der Aufruf einer Klassenfunktion führt aber immer zum Aufruf der Funktion, die dem Typ der tatsächlichen Instanz zugehört.
