Thema heute: Vererbung und Klassenhierarchien. Abgeleitete Klassen. Vererbung von Daten und Funktionen. Virtuelle Funktionen

Transkript

1 1 Thema heute: Vererbung und Klassenhierarchien Abgeleitete Klassen Vererbung von Daten und Funktionen Virtuelle Funktionen

2 2 Vererbung oft besitzen verschiedene Datentypen einen gemeinsamen Kern Beispiel: Auto, Lastwagen Beide sind offenbar Fahrzeuge, haben Räder, Gewicht, etc. Anderes Beispiel: Mitarbeiter Chef, Abteilungsleiter, Sekretaerin, etc. sind alle Kern: (abstrakte) Basisklasse Vererbung: eine abgeleitete Klasse erbt die Elemente des Basisklasse (inheritance) und verfügt über zusätzliche Eigenschaften

3 3 Beispiel: Die Basis Klasse Fahrzeug (Header File) #ifndef VEHIKEL_HPP #define VEHIKEL_HPP #include <iostream> using namespace std; class Fahrzeug { protected: int _Raeder; double _Gewicht; public: Fahrzeug (int Raeder, double Gewicht); int Raeder () const {return _Raeder;} double Gewicht () const {return _Gewicht;}

4 4 double Radlast () const; friend ostream& operator << (ostream& s, const Fahrzeug &v); const char *Name() const { return "Fahrzeug"; } }; #endif

5 5 Beispiel: Die Basis-Klasse Fahrzeug (Implementierung) // fahrzeug.cpp #include "fahrzeug.hpp" // Konstruktor Fahrzeug::Fahrzeug(int Raeder, double Gewicht) : _Raeder(Raeder), _Gewicht(Gewicht) {} // Gib das Gewicht pro Rad zurueck double Fahrzeug::Radlast() const { return _Gewicht / _Raeder; } // Ausgabe ostream& operator << (ostream& s, const Fahrzeug &v) {

6 6 s << "Das Fahrzeug hat " << v._raeder << ((v._raeder>1)?" Raeder":" Rad") << " und wiegt " << v._gewicht << " kg. "; } return s << endl;

7 7 Anwendung der Basis-Klasse Fahrzeug #include <iostream> #include "fahrzeug.hpp" using namespace std; int main() { Fahrzeug Auto(4,900.0), Motorrad(2,400.0), Laster(18, ), Ente(4,700.0); cout << Auto; cout << "Der Laster hat ein Gewicht von " << Laster.Radlast() << " kg pro Rad." << endl;

8 8 cout << "Das Motorrad wiegt " << Motorrad.Gewicht() << " kg." << endl; cout << Ente; cout << "Die Ente ist ein " << Ente.Name() << "." << endl; } return 0;

9 9 Das Programm liefert folgende Ausgabe: Das Fahrzeug hat 4 Raeder und wiegt 900 kg. Der Laster hat ein Gewicht von kg pro Rad. Das Motorrad wiegt 400 kg. Das Fahrzeug hat 4 Raeder und wiegt 700 kg. Die Ente ist ein Fahrzeug.

10 10 Die abgeleitete Klasse Auto (Header-File) #ifndef _AUTO_HPP #define _AUTO_HPP #include "fahrzeug.hpp" class Auto : public Fahrzeug { int _Passagiere; public: Auto(int Raeder, double Gewicht, int Leute = 4) : Fahrzeug(Raeder, Gewicht), _Passagiere(Leute) {} int Passagiere () const { return _Passagiere; } const char *Name () const {return "Auto";} int Fuehrerscheinklasse () const {return 3;} };

11 11 #endif

12 12 Die abgeleitete Klasse Laster (Header-File) #ifndef _LASTER_HPP #define _LASTER_HPP #include "fahrzeug.hpp" class Laster : public Fahrzeug { int _Besatzung; double _Ladung; public: Laster(int Raeder, double Gewicht, int Besatzung = 2, double Ladung = ) : Fahrzeug(Raeder, Gewicht), _Besatzung(Besatzung), _Ladung(Ladung) {}

13 13 double Effizienz () const { return _Ladung / (_Ladung + _Gewicht); } int Besatzung () const {return _Besatzung;} const char *Name () const { return "Lastwagen"; } int Fuehrerscheinklasse () const { return 2; } }; #endif

14 14 Anwendung der abgeleiteten Klassen #include <iostream> #include "fahrzeug.hpp" #include "auto.hpp" #include "laster.hpp" using namespace std; int main() { Fahrzeug Hochrad(1, 5.7); cout << Hochrad; cout << "Die Radlast des Hochrades betraegt " << Hochrad.Radlast() << " kg " << endl << "auf dem einzigen Rad." << endl << endl; Auto Ente(4, 700.0, 5);

15 15 cout << Ente; cout << "Die Ente fuehrt " << Ente.Passagiere() << " Passagiere mit sich. " << endl << "Die Radlast der Ente ist " << Ente.Radlast() << " kg pro Rad." << endl << "Die Ente ist ein " << Ente.Name() << "." << endl << endl; Laster Sattelschlepper(18, , 1, ); cout << Sattelschlepper; cout << "Die Effizienz des Sattelschleppers ist " << * Sattelschlepper.Effizienz() << " Prozent." << endl << "Der Sattelschlepper ist ein " << Sattelschlepper.Name() << "." << endl; } return 0;

16 16 Ausgabe des Programms Das Fahrzeug hat 1 Rad und wiegt 5.7 kg. Die Radlast des Hochrades betraegt 5.7 kg auf dem einzigen Rad. Das Fahrzeug hat 4 Raeder und wiegt 700 kg. Die Ente fuehrt 5 Passagiere mit sich. Die Radlast der Ente ist 175 kg pro Rad. Die Ente ist ein Auto. Das Fahrzeug hat 18 Raeder und wiegt 5700 kg. Die Effizienz des Sattelschleppers ist Prozent. Der Sattelschlepper ist ein Lastwagen.

17 17 Konstruktoren/Destruktoren bei Vererbung #include <iostream> using namespace std; class basis { public: basis() { cout << "Konstruktor fuer Klasse basis " << endl; } ~basis() { cout << "Destruktor fuer Klasse basis " << endl; } }; class abgeleitet : public basis { public: abgeleitet() { cout << "Konstruktor fuer Klasse abgeleitet " << endl;} ~abgeleitet() { cout << "Destruktor fuer Klasse abgeleitet " << endl; } };

18 18 int main() { cout << "Zuerst definiere Variable vom Typ basis : " << endl; basis b; cout << "Nun definiere Variable vom Typ abgeleitet : " << endl; abgeleitet a; cout << "Compiler ruft Destruktoren automatisch auf : " << endl; } return 0;

19 19 Ausgabe des Programms Zuerst definiere Variable vom Typ basis : Konstruktor fuer Klasse basis Nun definiere Variable vom Typ abgeleitet : Konstruktor fuer Klasse basis Konstruktor fuer Klasse abgeleitet Compiler ruft Destruktoren automatisch auf : Destruktor fuer Klasse abgeleitet Destruktor fuer Klasse basis Destruktor fuer Klasse basis

20 20 Anmerkungen zur Vererbung -1- Um eine Klasse B von einer Basis-klasse A abzuleiten, verwendet man die Deklaration class B : public A {... }; Die Basisklasse kann in mancherlei Hinsicht als Element der abgeleiteten Klasse aufgefasst werden. Die Basisklasse wird somit quasi in die abgeleitete Klasse eingebettet. Das Schlüsselwort public bedeutet, daß alle öffentlichen Daten von A von allen Funktionen auch außerhalb von B benutzt werden können. Jede Funktion kann einen B* in einen A* konvertieren.

21 21 Anmerkungen zur Vererbung -2- Wird stattdessen das Schlüsselwort private verwendet, so dürfen nur noch die Funktionen von B und friends von B die öffentlichen Daten von A benutzen, und nur diese dürfen einen B* in einen A* konvertieren. Abgeleitete Klassen haben im allgemeinen sowohl zusätzliche Elemente als auch zusätzliche Elementfunktionen, die sie von den anderen von der gleichen Basis- Klasse abgeleiteten Klassen unterscheiden. Die Element-Funktionen der abgeleiteten Klasse können auf die privaten Daten der Basisklasse zugreifen, wenn in deren Deklaration das Schlüsselwort protected anstatt von private verwendet wird. Die Verwendung von protected sollte aber nicht zur Gewohnheit werden. Die sauberere Lösung ist meistens die, bei der abgeleitete Klassen nicht auf die privaten Daten der Basisklasse zugreifen.

22 22 Anmerkungen zur Vererbung -3- Vererbung kann sich über mehrere Generationen erstrecken, d.h., abgeleitete Klassen können selbst wieder als Basisklasse anderer Klassen dienen. Mehrfachvererbung ist ebenfalls möglich, d.h. Klassen können von mehr als einer Basisklasse abgeleitet werden. Eine Klasse Wasserflugzeug könnte z.b. aus den Klassen Boot und Flugzeug abgeleitet werden durch class Wasserflugzeug : public Boot, public Flugzeug {... };

23 23 Beispiel: Problem bei Vererbung #include <iostream> #include "laster.hpp" #include "auto.hpp" using namespace std; int main() { Fahrzeug* Fuhrpark[3]; Fuhrpark[0] = new Fahrzeug( 1, 5.7); Fuhrpark[1] = new Auto ( 4, 700.0); Fuhrpark[2] = new Laster (18, ); } for (int i=0; i<3; i++) { cout << (Fuhrpark[i])->Name() << endl; } return 0;

24 24 Ausgabe des Programms Fahrzeug Fahrzeug Fahrzeug

25 25 Beispiel: Das gleiche Problem bei Vererbung #include <iostream> using namespace std; class basis { public: void name() const { cout << "basis" << endl; } }; class abgeleitet : public basis { public: void name() const { cout << "abgeleitet" << endl; } };

26 26 void AusgabeName(const basis &b){ b.name(); } int main() { basis b; abgeleitet a; cout << "Normale Ausgabe : " << endl; b.name(); a.name(); cout << "Ausgabe ueber Funktion AusgabeName : " << endl; AusgabeName(b); AusgabeName(a); } return 0;

27 27 Ausgabe des Programms Normale Ausgabe : basis abgeleitet Ausgabe ueber Funktion AusgabeName : basis basis

28 28 Beispiel: Ausweg durch virtuelle Funktionen #include <iostream> using namespace std; class basis { public: virtual void name() const { cout << "basis" << endl; } }; class abgeleitet : public basis { public: void name() const { cout << "abgeleitet" << endl; } };

29 29 void AusgabeName(const basis &b){ b.name(); } int main() { basis b; abgeleitet a; cout << "Normale Ausgabe : " << endl; b.name(); a.name(); cout << "Ausgabe ueber Funktion AusgabeName : " << endl; AusgabeName(b); AusgabeName(a); } return 0;

30 30 Ausgabe des Programms Normale Ausgabe : basis abgeleitet Ausgabe ueber Funktion AusgabeName : basis abgeleitet

31 31 Beispiel: Das Fahrzeug Ersetzt man entsprechend in der Deklaration der Klasse Fahrzeug die Deklaration der Funktion Name durch virtual char *Name () const { return "Fahrzeug"; } so wird die Funktion in den abgeleiteten Klassen nicht nur redefiniert, Pointer oder Referenzen auf die abgeleiteten Klassen, die auf die Basisklasse gecastet werden, benutzen die Elementfunktionen der abgeleiteten Klasse. Unser Beispielprogramm der Fuhrparks liefert jetzt das gewünschte Ergebnis: Fahrzeug Auto Lastwagen

32 32 Beispiel: Das Fahrzeug -2- Fügt man dem Programm die Zeile cout << (Fuhrpark[2])->Fahrzeug::Name() << endl; hinzu, so gibt es Fahrzeug aus. Man kann also die Benutzung der Funktion Name der Basisklasse durch Benutzung des Operators :: erzwingen.

33 33 Anmerkungen zu virtuellen Funktionen Virtuelle Funktionen sind Funktionen der Basisklasse, die in einer abgeleiteten Klassen redefiniert werden. Die Deklaration einer virtuellen Funktion in der Basisklasse ist durch das Schlüsselwort virtual gekennzeichnet. Bei der Redefinition in einer abgeleiteten Klasse braucht das Schlüsselwort virtual nicht mehr mitangegeben zu werden. Soll in einer abgeleiteten Klasse ausnahmsweise einmal die virtuelle Funktion der Basisklasse anstatt der redefinierten Funktion aufgerufen werden, so kann man dazu den Bereichsauflösungsoperator :: verwenden, z.b. Fahrzeug::Name();

34 34 Anmerkungen zu virtuellen Funktionen -2- Sobald polymorphe Objekte verwendet werden, sollten die Destruktoren virtuell sein. virtual Fahrzeug();

35 35 Laufzeittypüberprüfung #include <iostream> #include "auto.hpp" #include "laster.hpp" using namespace std; void SicherCasten(Fahrzeug *kfz) { Laster *p = dynamic_cast<laster *>(kfz); if( p ) { cout << "Die Effizienz betraegt " << p->effizienz() << endl; } else { cout << "Das ist kein Laster!" << endl; } } int main()

36 36 { } // Bemerkung: man darf die Variable vom Typ // Auto natuerlich nicht "auto" nennen, so wie // ich es in der Vorlesung versucht habe, weil // auto ein C++ Schluesselwort ist! Auto autom(4, , 5); Laster laster(6, , 3, 12); SicherCasten(&autom); SicherCasten(&laster); return 0;

37 37 Beispiel: Abstrakte Deklaration der Klasse Fahrzeug #ifndef VEHIKEL_HPP #define VEHIKEL_HPP #include <iostream> using namespace std; class Vehikel { protected: int _Raeder; double _Gewicht; public: Vehikel (int Raeder, double Gewicht); int Raeder () const {return _Raeder;} double Gewicht () const {return _Gewicht;} double Radlast () const;

38 38 }; friend ostream& operator << (ostream& s, const Vehikel &v); // Die beiden folgenden Funktionen sind rein virtuell. virtual const char *Name() const = 0; virtual int Fuehrerscheinklasse() const = 0; #endif

39 39 Beispiel: Eine abstrakte Klasse #include <iostream> #include "auto_v.hpp" #include "laster_v.hpp" using namespace std; int main() { // Vehikel Hochrad; // Verboten, da abstrakte Basisklasse Auto Ente(4, 700.0, 5); cout << "Typ : " << Ente.Name() << endl; cout << Ente; cout << "Die Ente fuehrt " << Ente.Passagiere() << " Passagiere mit sich." << endl << "Die Radlast der Ente ist " << Ente.Radlast() << " kg pro Rad." << endl;

40 40 cout << "Man kann ein " << Ente.Name() << " mit Fuehrerscheinklasse " << Ente.Fuehrerscheinklasse() << " fahren.\n\n"; Laster Sattelschlepper(18, , 1, ); cout << "Typ : " << Sattelschlepper.Name() << endl; cout << Sattelschlepper; cout << "Die Effizienz des Sattelschleppers ist " << * Sattelschlepper.Effizienz() << " Prozent.\n"; } cout << "Man kann einen " << Sattelschlepper.Name() << " mit Fuehrerscheinklasse " << Sattelschlepper.Fuehrerscheinklasse() << " fahren.\n"; return 0;

41 41

42 42 Dieses Programm produziert folgende Ausgabe: Typ : Auto Das Fahrzeug hat 4 Raeder und wiegt 700 kg. Die Ente fuehrt 5 Passagiere mit sich. Die Radlast der Ente ist 175 kg pro Rad. Man kann ein Auto mit Fuehrerscheinklasse 3 fahren. Typ : Lastwagen Das Fahrzeug hat 18 Raeder und wiegt 5700 kg. Die Effizienz des Sattelschleppers ist Prozent. Man kann einen Lastwagen mit Fuehrerscheinklasse 2 fahren.

43 43 Abstrakte Klassen Eine virtuelle Funktion, die in der Basisklasse als konstant Null vorinitialisiert ist, wird als rein virtuelle Funktion bezeichnet: virtual int rein virtuell(int, char *) = 0; Die Initialisierung =0 ist wie ein Schlüsselwort zu interpretieren und kann nicht auf normale Funktionen angewendet werden. Eine Klasse mit mindestens einer virtuellen Funktion heißt abstrakte Klasse. Diese werden ausschließlich als Basisklassen verwendet, d.h., um andere Klassen daraus abzuleiten. Objekte einer abstrakten Klasse können nicht erzeugt werden.

44 44 Abstrakte Klassen -2- Rein virtuelle Funktionen, die in einer abgeleiteten Klasse nicht redefiniert werden, bleiben rein virtuell. In diesem Fall ist auch die abgeleitete Klasse abstrakt. Abstrakte Klassen werden typischerweise zur Definition von Schnittstellen eingesetzt.