Tabelle virtueller Methoden

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche

Die Tabelle virtueller Methoden (engl.: 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.

Zuordnung der Tabellen virtueller Methoden (rechts) zu den Klassen. Dackel erbt von seinem Vorfahren Hund

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++, C# 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 Compilierzeit 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.