imported>Uncopy: /* Rein virtuelle Methoden */ Beispiel: Polymorphie mittels Nutzung der Basisklasse demonstriert

2024-02-19T09:58:05Z

Rein virtuelle Methoden: Beispiel: Polymorphie mittels Nutzung der Basisklasse demonstriert

Neue Seite

Eine '''virtuelle Methode''' ist in der [[Objektorientierte Programmierung|objektorientierten Programmierung]] eine [[Methode (Programmierung)|Methode]] einer [[Klasse (Programmierung)|Klasse]], deren Einsprungadresse erst zur Laufzeit ermittelt wird. Dieses sogenannte [[Dynamische Bindung|dynamische Binden]] ermöglicht es, Klassen von einer Oberklasse abzuleiten und dabei Funktionen zu [[Überschreiben (OOP)|überschreiben]] bzw. zu [[überladen]]. Das Konzept der virtuellen Methoden wird von einem [[Compiler]] (Übersetzer) zum Beispiel mittels [[Tabelle virtueller Methoden|Funktionstabellen]] umgesetzt.

In manchen Programmiersprachen wie [[Java (Programmiersprache)|Java]], [[Smalltalk (Programmiersprache)|Smalltalk]] und [[Python (Programmiersprache)|Python]] sind alle Methoden virtuell. Dagegen müssen in Sprachen wie [[C++]], [[C-Sharp|C#]], [[SystemVerilog]] oder [[Object Pascal]] Methoden für diesen Zweck mit dem Schlüsselwort <code>virtual</code> 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 (OOP)|Überschreiben]].

Durch das Ableiten von Klassen ergibt sich auch die sogenannte [[Polymorphie (Programmierung)|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 [[Prozessor|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 [[Prozessor|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 (Programmiersprache)|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 ({{lang|en|''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 [[Nullwert|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'''

<syntaxhighlight lang="cpp">
#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);
}
</syntaxhighlight>

== Virtuelle Destruktoren ==
Eine weitere Eigenheit von C++ sind [[Destruktor]]en, die für abschließende Aufgaben wie [[Speicherleck#Explizite Speicherfreigabe|Speicherfreigabe]] verwendet werden. Jede Klasse, deren Attribute nicht primitive Typen sind oder die andere [[Ressource#Informatik|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 <code>virtual</code> deklariert sein.

Folgendes Beispiel zeigt die Verwendung und Vererbung von nicht-virtuellen Destruktoren, was zu undefiniertem Verhalten führt.
<syntaxhighlight lang="cpp">
#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>();
}
</syntaxhighlight>
Eine mögliche Ausgabe wäre:
Zerstöre B
Zerstöre A
Zerstöre A
[[Kategorie:Objektorientierte Programmierung]]
[[Kategorie:Unterprogramm]]

[[sv:Funktion (programmering)#Virtuell funktion]]

Virtuelle Methode - Versionsgeschichte

imported>Uncopy: /* Rein virtuelle Methoden */ Beispiel: Polymorphie mittels Nutzung der Basisklasse demonstriert