Virtuelle Methode

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

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 virtueller Tabellen umgesetzt.

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

Ableiten von Klassen und Überschreiben von Methoden[Bearbeiten]

In objektorientierten Programmiersprachen wie C++, C#, Object Pascal 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.

Durch das Ableiten von Klassen ergibt sich auch die so genannte Polymorphie. Jede Klasse repräsentiert einen eigenen Datentyp. Abgeleitete Klassen haben mindestens einen weiteren Datentyp, nämlich den der Basisklasse (auch als Oberklasse oder Superklasse 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 abgeleitet wurde) in der Liste abgelegt sind.

Problematik für den Übersetzer[Bearbeiten]

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[Bearbeiten]

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 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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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>
 
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