Virtuelle Methode

Virtuelle Methode ist ein Begriff, der im Zusammenhang mit objektorientierten Programmiersprachen benutzt wird. Sie ist eine Methode einer Klasse, deren Einsprungadresse erst zur Laufzeit ermittelt wird. Dieses sogenannte dynamische Binden ermöglicht es, Klassen von einer Oberklasse abzuleiten und dabei Funktionen zu überschreiben bzw. zu überlagern. Das Konzept der virtuellen Methoden wird von einem Übersetzer (Compiler) z. B. mittels virtueller Tabellen umgesetzt.

Programmierer der Sprachen C++, SystemVerilog oder Delphi müssen sich explizit mit dieser Thematik auseinandersetzen und entscheiden, welche Methoden sie als „virtuell“ definieren. In anderen objektorientierten Programmiersprachen, wie z. B. Java, Smalltalk und Python sind alle Methoden automatisch virtuell.

Ableiten von Klassen und Überschreiben von Methoden

In objektorientierten Programmiersprachen wie z. B. C++, C#, Delphi oder Java ist es möglich, Klassen zu erzeugen, indem man sie von anderen Klassen ableitet. Abgeleitete Klassen besitzen alle Methoden und Datenfelder der ursprünglichen Klasse und können durch weitere Felder und Methoden erweitert werden. In einigen Fällen ist es allerdings wünschenswert, bereits existierende Methoden abzuändern, d. h. sie neu zu schreiben. In diesem Fall spricht man von Überschreiben (C++, C#, Delphi, Java).

Durch das Ableiten von Klassen ergibt sich auch die so genannte Polymorphie (Vielgestaltigkeit). Jede Klasse repräsentiert einen eigenen Datentyp. Abgeleitete Klassen haben mindestens einen weiteren Datentyp, nämlich den der Originalklasse (auch als Basisklasse oder Oberklasse bezeichnet). Dadurch ist es zum Beispiel möglich, eine Liste von Objekten der Klasse A zu benutzen, obwohl in Wirklichkeit auch Objekte der Klasse B (die von A abgleitet wurde) in der Liste abgelegt sind.

Problematik für den Übersetzer

Ein Übersetzer (Compiler) versucht während der Übersetzung, für jede aufgerufene Funktion eine Adresse im Speicher festzulegen, an der eine Funktion oder Methode beginnt. Im späteren Programm wird die CPU bei einem Aufruf die entsprechende Adresse anspringen und weiterarbeiten (daneben wird noch einige administrative Arbeit notwendig, die hier nicht weiter von Bedeutung ist). Bei abgeleiteten Klassen mit überschriebenen oder überlagerten Methoden ist jedoch nicht immer zur Übersetzungszeit (Compilezeit) bekannt, welche Methode aufzurufen ist. Im Beispiel mit der Liste kann der Übersetzer zum Beispiel nicht immer wissen, wann andere Objekte als Objekte vom Typ A in der Liste auftauchen.

Lösung: Indirekte Adressierung

Eine Lösung ist die indirekte Adressierung über eine Tabelle. Kann der Übersetzer nicht festlegen, welche Methode angesprungen werden soll, wird nicht eine Einsprungadresse angegeben, sondern nur ein Verweis auf einen Eintrag in der Virtuellen Tabelle abgelegt. Darin stehen die konkreten Einsprungadressen, die während des Programmlaufs angesprungen werden sollen.

Beispiel: Eine Liste enthält Elemente des Typs A und B. A ist Oberklasse von B und B überschreibt die Methode m aus A. Nun soll für jedes Element die Methode m aufgerufen werden. Zu jeder Klasse gibt es daher eine Tabelle mit Adressen von Funktionen. Die verzeichneten Adressen der Tabelle von Objekten des Typs B sind andere als die der Tabelle von Objekten des Typs A. Im Maschinencode wird nun die CPU angewiesen, die Funktion aufzurufen, die an der Tabellenposition 'm' des aktuellen Objekts steht.

Abstrakte, virtuelle Methoden

Virtuelle Methoden können zusätzlich auch noch abstrakt sein. In der Klasse, in der die Methode deklariert wird, bleibt die Methode leer, kann aber theoretisch noch aufgerufen werden. Erst in einer abgeleiteten Klasse wird die abstrakte Methode überschrieben und kann dann benutzt werden.

Wenn eine Klasse eine oder mehrere abstrakte Methoden enthält, wird sie als abstrakte Klasse bezeichnet. In C++ und Java ist es nicht möglich, ein Objekt einer abstrakten Klasse zu erzeugen. Borland Delphi lässt dies zu, allerdings wird bei dem Aufruf einer abstrakten Methode eine Exception ausgelöst.

Rein virtuelle Methoden

Rein virtuelle Methoden (Pure virtual functions) erweitern den Begriff der abstrakten Methode noch weiter. Da eine abstrakte, virtuelle Methode theoretisch noch aufgerufen werden kann, setzt man zum Beispiel in C++ die Methoden explizit gleich null. Dadurch können diese Methoden nicht mehr aufgerufen werden und von der Klasse kann kein Objekt erstellt werden. Abgeleitete Klassen müssen diese Methoden erst implementieren, nur dann kann ein Objekt von ihnen erzeugt werden.

Beispiel:

# include <iostream>
using namespace std;
 
class Tier {
public:
    virtual void essen() = 0; // Rein virtuelle Methode
};
 
class Wolf : public Tier {
public:
    void essen() { cout << "Wölfe können essen!" << endl; } // Implementierung der virtuellen Methode
};
 
int main() {
    Wolf wolf1;
    wolf1.essen(); // Ok
}

Virtuelle Destruktoren

Eine weitere Eigenheit von C++ sind Destruktoren, die für Tätigkeiten wie Speicherfreigabe verwendet werden. Jede Klasse, deren Attribute nicht primitive Typen sind oder die andere Ressourcen verwendet (wie z. B. eine Datenbankverbindung), sollte diese unbedingt in ihrem Destruktor freigeben. Um immer auf den richtigen Destruktor zugreifen zu können, muss der Destruktor des Urahnen als virtual deklariert sein.

Folgendes Beispiel zeigt die Verwendung von Vererbung und nicht-virtuellen Destruktoren, was zu undefiniertem Verhalten führt.

#include <iostream>
 
class A {
public:
    A() { }
    ~A() { std::cout << "Zerstöre A" << std::endl; }
};
 
class B : public A {
public:
    B() { }
    ~B() { std::cout << "Zerstöre B" << std::endl; }
};
 
int main()
{
    A* b1 = new B;
    B* b2 = new B;
 
    delete b1;  // Gemäß C++-Standard undefiniertes Verhalten.
                // Meist wird nur ~A() aufgerufen, da ~A() nicht virtuell.
    delete b2;  // Destruktoren ~B() und ~A() werden aufgerufen
 
    return 0;
}

Eine mögliche Ausgabe wäre

Zerstöre A
Zerstöre B
Zerstöre A