Virtuelle Methode

Eine virtuelle Methode ist in der objektorientierten Programmierung 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 überladen. Das Konzept der virtuellen Methoden wird von einem Compiler (Übersetzer) zum Beispiel mittels Funktionstabellen umgesetzt.

In manchen Programmiersprachen wie Java, Smalltalk und Python sind alle Methoden virtuell. Dagegen müssen in Sprachen wie C , C#, SystemVerilog oder Object Pascal Methoden für diesen Zweck mit dem Schlüsselwort virtual gekennzeichnet werden, was die zusätzliche Möglichkeit bietet, das Überladen in Unterklassen zu verhindern.

Ableiten von Klassen und Überschreiben von Methoden

In objektorientierten Programmiersprachen wie C , C#, Object Pascal oder Java können Klassen erzeugt werden, 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.

Durch das Ableiten von Klassen ergibt sich auch die sogenannte Polymorphie. Jede Klasse repräsentiert einen eigenen Datentyp. Abgeleitete Klassen haben mindestens einen weiteren Datentyp, nämlich den der Basisklasse (auch als Ober-, Super- oder Elternklasse bezeichnet). Dadurch ist es zum Beispiel möglich, eine Liste von Objekten der Klasse A zu benutzen, obwohl tatsächlich auch Objekte der Klasse B (die von A abgeleitet wurde) in der Liste abgelegt sind.

Problematik für den Übersetzer

Ein 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 überladenen Methoden ist jedoch nicht immer zur Übersetzungszeit bekannt, welche Methode aufzurufen ist. Im Beispiel mit der Liste (s. u.) 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 feststellen, welche Methode angesprungen werden soll, wird nicht eine Einsprungadresse angegeben, sondern nur ein Verweis auf einen Eintrag in der Funktionstabelle 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. Object Pascal 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>

struct Tier {
    // Rein virtuelle Methode
    virtual void fressen() = 0;
};

struct Wolf: Tier {
    // Implementierung der virtuellen Methode
    void fressen() {
        std::cout << "Der Wolf frisst Fleisch." << std::endl;
    }
};

struct Schaf: Tier {
    // Implementierung der virtuellen Methode
    void fressen() {
        std::cout << "Das Schaf frisst Pflanzen." << std::endl;
    }
};

// Allgemeine Funktion die mit jedem Tier benutzt werden kann
void tier_fuettern(Tier& tier) {
    tier.fressen();
}

int main() {
    Wolf wotan;
    Schaf dolly;
    tier_fuettern(wotan);
    tier_fuettern(dolly);
}

Virtuelle Destruktoren

Eine weitere Eigenheit von C sind Destruktoren, die für abschließende Aufgaben 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 und Vererbung von nicht-virtuellen Destruktoren, was zu undefiniertem Verhalten führt.

#include <iostream>
#include <memory>

using namespace std;

struct A {
    A() {}
    ~A() {
        cout << "Zerstöre A" << endl;
    }
};

struct B: A {
    B() {}
    ~B() {
        cout << "Zerstöre B" << endl;
    }
};

int main() {
    // Gemäß C  -Standard undefiniertes Verhalten
    // Meist wird am Ende nur ~A() aufgerufen, da ~A() nicht virtuell ist
    unique_ptr<A> b1 = make_unique<B>();

    // Am Ende werden Destruktoren ~B() und ~A() aufgerufen
    unique_ptr<B> b2 = make_unique<B>();
}

Eine mögliche Ausgabe wäre:

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