7.1 7 Vererbung Eine von der Basisklasse B abgeleitete Klasse A erbt alle Attribute und Methoden von B. Ein Objekt der Klasse A besitzt ein Slice der Klasse B und ein Slice der Klasse A. Jeder Konstruktor der Klasse A muss alle neuen Attribute seiner Klasse initialisieren. Die Initialisierung der ererbten Attribute wird an einen Konstruktor der Basisklasse B delegiert. Konstruktor Das Slice der Basisklasse muss vor dem Slice der abgeleiteten Klasse initialisiert werden. Dies geschieht in der Initialisierungsliste des Konstruktors mit einem Aufruf eines Basisklassen-Konstruktors. In der Initialisierungsliste können keine Attribute der Basisklasse direkt initialisiert werden, da hierfür die Zugriffsrechte fehlen. Falls kein Konstruktor in der Initialisierungsliste angegeben wird, versucht C++, den Default-Konstruktor zu verwenden. Neue Attribute können auch in der Initialisierungsliste initialisiert werden. Erben von Konstruktoren (neu in C++ 11): Bisher konnte eine Klasse keine Konstruktoren ihrer Basisklasse erben. In der abgeleiteten Klasse standen nur die Konstruktoren zur Verfügung, welche explizit für diese Klasse definiert wurden (mit Ausnahme der automatisch vom Compiler generierten Konstruktoren). Seit C++ 11 ist es möglich, alle (und nur alle auf einmal) Konstruktoren der Basisklasse zu erben. Beispiel: class Student : Person{ int m_matrikelnummer = 0; using Person::Person; Student(const string& name, const string& vorname, int matrikel) : Person{name, vorname, m_matrikelnummer{matrikel{ using Person::Person führt dazu, dass alle Konstruktoren von Person geerbt werden. Die Initialisierung der Matrikelnummer bei der Deklaration ist wichtig, falls der geerbte Konstruktor von Person aufgerufen wird, also der Konstruktor, welcher nur 2 Parameter entgegennimmt. Destruktor Der Destruktor einer abgeleiteten Klasse löscht alle eigenen dynamischen Attribute des Objekts. Am Schluss werden die ererbten Attribute gelöscht. Dies wird an den Basisklassen-Destruktor delegiert, indem er automatisch aufgerufen wird. Für eine abgeleitete Klasse muss nur ein Destruktor programmiert werden, wenn sie entweder dynamische Attribute enthält oder aber Klassenattribute, die beispielsweise Instanzen zählen. Der Destruktor wird immer auch für statisch (auf dem Stack) erzeugte Objekte aufgerufen, bevor sie vom Stack entfernt werden. Destruktoren von Klassen, von welchen weitere Ableitungen oder polymorphe Nutzung zu erwarten sind, soll der Destruktor virtuell deklariert werden. Damit ist sichergestellt, dass immer der richtige Destruktor aufgerufen wird.
7.2 Ein Beispiel // Deklaration der Basisklasse class Person { string m_nachname; string m_vorname; Person(const string& vorname, const string& name); void setnachname(const string& nachname) { m_nachname = nachname; void setvorname(const string& vorname) { m_vorname = vorname; void print() const; // Implementation fehlender Methoden in der Basisklasse void Person::print() const { cout << "Nachname: " << m_nachname << endl; cout << "Vorname: " << m_vorname << endl; Person::Person(const string& v, const string& n): m_vorname{v, m_nachname{n{ Von der Klasse Person wird die Klasse Student abgeleitet. Sie enthält die Matrikelnummer als neues, zusätzliches Attribut: // Deklaration der abgeleiteten Klasse Student class Student : Person{ int m_matrikelnummer; Student(const string& vorname, const string& name, int matrikel); void setmatrikelnummer(int nr) { m_matrikelnummer = nr; void print() const; // Implementation der abgeleiteten Klasse Student Student::Student(const string& v, const string& n, int m):person{v,n, m_matrikelnummer{m{ void Student::print() const { Person::print(); cout << "Matrikelnummer: " << m_matrikelnummer << endl; Zeiger und Referenzen Ähnlich, wie es auch in Java zulässig ist, an eine Referenz ein typenfremdes Objekt anzuhängen, dürfen Sie in C++ an einen Zeiger oder eine Referenz ein Objekt zuweisen, welches einen fremden Typ aufweist. In den folgenden Punkten sind die dafür gültigen Regeln beschrieben: Das einem Zeiger oder einer Referenz zugewiesene Objekt gehört zu einer Klasse, die vom Zieltyp der Referenz oder des Zeigers abgeleitet ist. In einem solchen Fall darf das Objekt ohne explizite Typkonvertierung an die Referenz bzw. den Zeiger zugewiesen werden. Der Compiler führt einen impliziten Up-Cast durch. Beispiel: Person* p = new Student{"Daniel", "Meier", 496285 Einem Zeiger oder einer Referenz des Zieltyps A darf kein Objekt einer Basisklasse von A zugewiesen werden. Eine solche Zuweisung ist allerdings erlaubt, sofern die Quelle der Zuweisung selbst ein Zeiger bzw. eine Referenz ist und das Objekt, das sich dahinter versteckt, aus der Klasse A oder einer von A abgeleiteten Klasse stammt. Sie hat aber immer durch eine explizite Konversion (Down-Cast) zu erfolgen. Beispiele:
7.3 Student* s1 = new Student{... Person* p = s1; // erlaubt: impliziter Up-Cast Student* s2 = p; // verboten, obschon das Objekt eigentlich passt. Student* s2 = static_cast<student*>(p); // erlaubt: expliziter Down-cast Unzulässige Typkonvertierungen haben folgende Auswirkungen: Wird ein traditioneller C-Cast oder static_cast verwendet, kann ein Laufzeitfehler auftreten. Die Benutzung eines dynamic_cast ist eher zu empfehlen: Schlägt die Umwandlung fehl, gibt sie 0 zurück (bei Zeigern) oder wirft eine Ausnahme (bei Referenzen: bad_castexception). Typen-Informationen Um Fehler bei einem Down-Cast zu vermeiden, ist es manchmal nötig, im voraus herauszufinden, ob der Typ eines Objekts passt. Der Operator dynamic_cast nutzt die für jede Klasse vorhandene Typen-Information, um herauszufinden, ob und wie ein korrekter Cast möglich ist. Er wird in Situationen verwendet, in welchen der Compiler nicht in der Lage ist zu entscheiden, ob ein Cast gültig ist. dynamic_cast prüft die Gültigkeit erst zur Laufzeit! Mit dem Operator typeid kann das Typen-Informations-Objekt einer Klasse explizit abgefragt werden: Er gibt die Referenz auf ein solches Objekt zurück. Damit sind genaue Typenprüfungen im voraus möglich (RTTI. Negativer Einfluss auf die Performance. Muss im Visual Studio explizit eingeschaltet werden). Beispiel: #include "typeinfo.h" Person* p = new Person(...); Person* q = new Student(...); const type_info& tp = typeid(*p); const type_info& tq = typeid(*q); if (tp==tq) cout << "Die beiden Typen sind identisch." << endl; if (tp.before(tq)) cout << "tp ist Basisklasse von tq" << endl; Auf type_info Objekten sind folgende Operatoren und Methoden definiert: Die Operatoren == und!=. Die Methoden bool before(const type_info&) zur Ermittlung der Rangfolge in der Vererbungshierarchie und const char* name() zur Ermittlung des Typen-Namens. Tip: Benutzen Sie dynamische Casts bzw. RTTI nur, wenn unbedingt erforderlich. Bevorzugen Sie polymorphe Zugriffe. Polymorphie C++ unterstützt wie Java polymorphe Zugriffe; dies allerdings mit einigen Unterschieden. Beim Aufruf einer Methode über einen Zeiger oder eine Referenz wird die zum Typ des Objekts passende Methode gewählt, sofern für die entsprechende Methode Polymorphie eingeschaltet ist (in Java ist sie standardmässig eingeschaltet und kann mit final ausgeschaltet werden. In C++ ist sie standardmässig ausgeschaltet und kann mit virtual eingeschaltet werden). Person* pp = new Person{... Person* ps = new Student{... pp->print(); ps->print(); // ruft Student::print() auf, falls print() virtuell ist Anstelle eines Objekts der Klasse B kann auch ein Objekt einer von B abgeleiteten Klasse A verwendet werden. Das Objekt der Klasse A ist polymorph: Es kann sich wie ein Objekt der Klasse A oder wie ein Objekt der Klasse B verhalten.
7.4 Werden Methoden einer Basisklasse überschrieben, sind sie nur dann polymorph, wenn die Basisklassen- Version als virtuell deklariert wurde. Virtuelle Methoden erfordern einen etwas höheren Aufwand beim Aufruf. Deklarieren Sie Methoden nur dann virtuell, wenn erforderlich! Werden in abgeleiteten Klassen Attribute definiert, deren Name bereits in der Basisklasse existiert, verdeckt das neue Attribut das alte. Vermeiden Sie dies unbedingt. Falls sich doch einmal ein Verdeckungseffekt nicht vermeiden lässt, können Sie durch Qualifikation eindeutig auf beide Attribute zugreifen: class Basis{ : int m_i; class Abgeleitet : Basis{ int m_i; Abgeleitet(int wert) : m_i(wert){ cout << "Attribut der abgeleiteten Klasse: " << m_i << endl; cout << "Attribut der Basisklasse: " << Basis::m_i << endl; cout << "Attribut der Basisklasse: " << static_cast<basis*>(this)->m_i << endl; Methoden überladen Methoden gleichen Namens aber unterschiedlicher Signatur können koexistieren (wie in Java). Manchmal muss man allerdings hinschauen um herauszufinden, welche Methode wirklich aufgerufen wird. Beispiel: Es sei die Klasse Sohn von Vater abgeleitet. void Vater::func(char) void Sohn::func(int) ~~~ Sohn s; s.func(5); // Sohn::func(), da Vater keine passende Überladung anbietet. s.func( A ); // Sohn::func(), da Sohn::func auch für char passt. In unklaren Fällen kann die gewünschte Methode explizit aufgerufen werden: s.vater::func( A ); oder using Vater::f. Methoden überschreiben Die überschreibende Methode muss dieselbe Signatur besitzen wie die überschriebene Methode. Der Rückgabetyp muss so gewählt werden, dass die neue Methode im selben Kontext verwendet werden kann wie die alte. Das heisst: Der Rückgabetyp muss identisch sein, wenn es sich um ein Objekt oder einen primitiven Wert handelt. Wird ein Zeiger oder eine Referenz zurückgegeben, darf das Ziel-Objekt auch vom ursprünglichen Rückgabe- Typ abgeleitet sein (Spezialisierung). Ist die überschriebene Methode nicht virtuell, entscheidet der statische Typ des Objekts bzw. des Zeigers/ Referenz über die Wahl der Version der aufgerufenen Methode. Ist die überschriebenen Methode virtuell und wird sie am Objekt direkt aufgerufen, kommt die im Objekt definierte Methode zu Einsatz (keine Polymorphie). Ist die überschriebenen Methode virtuell und wird sie über einen Zeiger oder eine Referenz aufgerufen, wird der Typ des Objekts dynamisch ermittelt und die passende Methoden-Version aufgerufen. Wenn der Polymorphie-Effekt greifen soll, kann die passende Methode erst zur Laufzeit ermittelt werden. Diesen langsameren Prozess bezeichnet man als dynamische oder späte Bindung. In allen anderen Fällen wird die
7.5 schnellere statische oder frühe Bindung verwendet. Hier wird bereits zur Compilierzeit die passende Methode ausgewählt. Wird eine Methode in der Basisklasse als virtual deklariert, sind alle später überschriebenen Versionen automatisch auch virtuell. Destruktoren in Klassen, von welchen abgeleitet werden soll, müssen virtual deklariert werden, damit eine Löschung eines Objekts (von einem Zeiger aus) stets den richtigen Destruktor verwendet. Konstruktoren können nicht virtuell sein (ergibt auch gar keinen Sinn). Private Methoden sollen nicht virtual deklariert werden, da sie von aussen nicht benutzt werden können. In C++ 11 gibt es einige Neuerungen, die zur Verwendung empfohlen werden: Methoden können als überschrieben ausgezeichnet werden. Dies ermöglicht es dem Compiler, Flüchtigkeitsfehler beim Überschreiben zu erkennen (z.b. ein Vertipper beim Namen, welcher ohne Markierung stillschweigend als neue Methode akzeptiert würde). class Person{ virtual void print() {... : class Student : Person{ virtual void print() override { : Person::print(); : Methoden, welche nicht weiter überschrieben werden sollen, können neu als final markiert werden. Zum Beispiel in Student: void print() final override{... Diese Methode wurde hier überschrieben, darf aber nicht in einer abgeleiteten Klasse nochmals überschrieben werden (also kein virtual!). Zugriffsrechte In der Basisklasse deklariert als... Klasse vererbt als... Zugriffsrechte in der abgeleiteten Klasse kein Zugriff (ausser in der Basisklasse als friend deklariert) kein Zugriff (ausser in der Basisklasse als friend deklariert) kein Zugriff (ausser in der Basisklasse als friend deklariert)
7.6 Friends Im Abschnitt über Zugriffsrechte haben wir gesehen, wie man den Zugriff auf Elemente einer Klasse einschränken kann. Manchmal wäre es allerdings schön, wenn eine Klasse einer anderen Sonderrechte gewähren könnte, ohne sich aber zugleich auch für alle Welt öffnen zu müssen. Dieser Fall tritt beispielsweise ein, wenn es angezeigt erscheint, einer anderen Klasse aus Gründen der Performance Zugriff auf interne Methoden oder Attribute zu gewähren, ohne dass zwischen den beiden Klassen eine verwandtschaftliche Beziehung besteht. Beispiel: Für die Klassen Matrix und Vector: Multiplikation von Matrizen mit Vektoren. Sonderrechte können auf zwei Arten gewährt werden: Auf der Stufe «Methode»: Einer fremden Methode kann der Zugriff auf eigene Elemente erlaubt werden. Auf der Stufe «Klasse»: Einer anderen Klasse kann der Zugriff auf eigene Elemente erlaubt werden. Beispiele: class A{ // verschiedene Elemente der Klasse A friend B::fb(); // fb() aus der Klasse B darf auf Elemente der Klasse A zugreifen. friend class C; // alle Elemente der Klasse C dürfen auf Elemente von A zugreifen. class B{ int fb(){... class C{ Mehrfach-Vererbung C++ erlaubt Mehrfach-Vererbung. Dieses an sich mächtige Werkzeug kann allerdings auch zu Problemen mit Namenskonflikten und Mehrdeutigkeiten führen: Ein Basisklassen-Slice kann in einem abgeleiteten Objekt mehrfach vorkommen, so dass ein Methoden-Aufruf, welcher dieses Slice benutzt, nicht entscheiden kann, welches er verwenden soll (führt zu einem Compiler-Fehler). Person Mitarbeiter Student Dozent Assistent Hilfsassistent Dieses Problem kann mit Hilfe virtueller Basisklassen behoben werden: Erbt eine abgeleitete Klasse von einer Basisklasse virtuell, stellt der Compiler sicher, dass jedes Slice nur genau einmal in die abgeleitete Klasse eingebaut wird. Es stellt sich allerdings noch die Frage, welcher Basisklassen-Konstruktor im abgeleiteten Konstruktor aufgerufen wird: Dieses Problem wird durch einen expliziten Konstruktor-Aufruf beseitigt.
7.7 Person p("daniel", "Meier"); Assistent a(p,...); Student s(p,...); Hilfsassistent h(a, s,...); cout << h.setnachname(); // Compiler-Fehler Hilfsassistent erbt die Methode setnachname() gleich doppelt, einmal via Assistent und einmal via Student. Der Compiler weiss nicht, welche er benutzen soll. Es ist auch nicht garantiert, dass die beiden Person- Slices die selbe Information enthalten. Diese Art von Eindeutigkeitsproblemen können mit virtuellen Basisklassen gelöst werden: class Student : virtual Person{ //... class Mitabeiter : virtual Person{ //... class Assistent : Mitarbeiter{ //... class Hilfsassistent : Student, Assistent{ // eigene Attribute Hilfsassistent(const Student& s, const Assistent& a,...) : Person(...), Assistent(a), Student(s){... Wird eine Basisklasse durch Mehrfachvererbung über mehrere Wege an eine Klasse vererbt, besitzen Objekte dieser Klasse mehrere Instanzen des Basisklassen-Slices. Durch Vererbung als virtuelle Basisklasse wird sichergestellt, dass das Basisklassen-Slice nur einmal in das Objekt eingebaut wird. Mit anderen Worten: Die abgeleiteten Klassen Student, Mitarbeiter usw. teilen sich ein gemeinsames Person-Slice. Schliesslich stellt sich noch die Frage, wann bzw. durch wen das gemeinsame Slice initialisiert wird: Der Konstruktor muss in dem Objekt, das als eigenständiges Objekt konstruiert werden soll, explizit oder implizit aufgerufen werden (ein impliziter Aufruf erfolgt durch den Compiler bei fehlendem explizitem Aufruf: Er benutzt den Standard-Konstruktor oder erzeugt einen Fehler, falls dieser nicht vorhanden ist). In unserem Beispiel ist das eigenständige Objekt der Hilfsassistent, während Student und Assistent nur als dessen Komponenten in Erscheinung treten. Abstrakte Klassen (rein virtuelle Methoden) Eine explizite Deklaration einer abstrakten Klasse, wie in Java, existiert in C++ nicht. Es können allerdings Methoden einer Klasse als rein virtuelle Methoden deklariert werden, was der Deklaration einer abstrakten Methode in Java entspricht. Dadurch wird eine C++ Klasse implizit abstrakt, d.h. es können von ihr keine Instanzen gezogen werden. Eine von einer solchen Klasse abgeleitete Klasse kann hingegen instanziert werden, sofern sie alle rein virtuellen Methoden überschreibt. Eine rein virtuelle Methode wird wie folgt deklariert: class Shape{ virtual void draw() = 0; // weitere Elemente der Klasse // diese Methode ist abstrakt, d.h. rein virtuell Im weiteren gelten ähnliche Regeln wie in Java: Wenn von einer abstrakten Klasse B eine Klasse A abgeleitet wird, welche nicht alle rein virtuellen Methoden überschreibt, ist sie ebenfalls abstrakt.