C++-Programmierung/ Objektorientierte Programmierung/ Methoden (nicht) überschreiben

Aus Wikibooks
Zur Navigation springen Zur Suche springen


Im letzten Kapitel haben Sie die Vererbung kennengelernt. Auch ist Ihnen bereits bekannt, dass eine Funktion oder Methode überladen werden kann, indem man für einen Funktionsnamen mehrere unterschiedliche Deklarationen tätigt. Es stellt sich nun also die Frage, wie der Compiler reagiert, wenn wir in einer abgeleiteten Klasse eine Methode deklarieren, die in der Basisklasse unter dem gleichen Namen bereits existiert.

Dieser Vorgang wird als Überschreiben einer Methode bezeichnet. Man könnte nun natürlich annehmen, dass das Überschreiben nur für die entsprechende Signatur gilt, dies ist jedoch nicht der Fall. Eine Methode gleichen Namens, verdeckt alle Überladungen in der Basisklasse. Folgendes Beispiel soll das Verhalten klären:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 struct Base{
 4     void f(){ std::cout << "void Base::f()" << std::endl; }
 5     void f(int){ std::cout << "void Base::f(int)" << std::endl; }
 6 };
 7 
 8 struct A: Base{};
 9 
10 struct B: Base{
11     void f(double){ std::cout << "void B::f(double)" << std::endl; }
12 };
13 
14 int main(){
15     A a; // Nutzt f() aus Base, da keine eigene Methode f() existiert
16     B b; // Überschreibt alle Methoden f()
17 
18     a.f();  // void Base::f();
19     a.f(5); // void Base::f(int);
20 
21     // b.f(); // Compilierfehler: kein passendes f() in B; Base::f() ist verdeckt
22     b.f(5.4); // void B::f(double);
23     b.f(5);   // void B::f(double); (implizite Konvertierung nach double)
24 
25     // expliziter Aufruf der Basisklassenmethoden
26     b.Base::f();    // void Base::f();
27     b.Base::f(5.4); // void Base::f(int); (implizite Konvertierung nach int)
28     b.Base::f(5);   // void Base::f(int);
29 }

Wie sie sehen, können die Methoden der Basisklasse durch explizite Angabe der selben aufgerufen werden. Alternativ wäre auch ein static_cast von b möglich, dies führt jedoch zu schlecht lesbarem und fehleranfälligen Code und sollte daher vermieden werden. Fehleranfällig ist er, weil ein static_cast natürlich eine willkürliche Konvertierung bewirken kann, also in einen Typen von dem b gar nicht abgeleitet ist, aber auch wenn das Konvertierungsziel eine Basisklasse ist, können sich unerwartete Effekte einstellen:

Crystal Clear action button cancel.svg

Schlechter Stil! Bitte nicht verwenden!


1 int main(){
2     B b; // Überschreibt alle Methoden f()
3 
4     // expliziter Aufruf der Basisklassenmethoden
5     static_cast< Base& >(b).Base::f(); // Gleichwertig zu "b.Base::f()"
6     static_cast< Base >(b).Base::f(); // Erzeugt eine temporäre Kopie von a und ruft für diese Base::f() auf
7 }

Um zu sehen, dass tatsächlich eine Kopie erzeugt wird, können sie Base einen entsprechenden Kopierkonstruktor hinzufügen. Natürlich benötigt Base dann auch einen Standardkonstruktor.

Symbol opinion vote.svg
Hinweis

Im Kapitel Virtuelle Methoden werden Sie eine scheinbar ähnliche Technik kennenlernen, diese hat jedoch im Gegensatz zum Überschreiben von Methoden nichts mit Funktionsüberladung zu tun und sollte keinesfalls damit verwechselt werden!