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: Chef, Abteilungsleiter, Sekretaerin, etc. sind alle Mitarbeiter 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 (Deklaration) class Fahrzeug { protected: int _Raeder; double _Gewicht; public: Fahrzeug (int Raeder, double Gewicht); int Raeder () const {return _Raeder;} double Gewicht () const {return _Gewicht;} double Radlast () const; friend ostream& operator << (ostream& s, const Fahrzeug &v); const char *Name() const { return "Fahrzeug"; } };

4 4 Beispiel: Die Basis-Klasse Fahrzeug (Implementierung) Fahrzeug::Fahrzeug(int Raeder, double Gewicht) : _Raeder(Raeder), _Gewicht(Gewicht) {} double Fahrzeug::Radlast() const { return _Gewicht / _Raeder; } ostream& operator << (ostream& s, const Fahrzeug &v) { s << "Das Fahrzeug hat " << v._raeder << ((v._raeder>1)?" Raeder":" Rad") << " und wiegt " << v._gewicht << " kg. "; return s << endl; }

5 5 Anwendung der Basis-Klasse Fahrzeug int main() { Fahrzeug Auto(4,900.0), Motorrad(2,400.0), Laster(18, ), Ente(4,700.0); cout << Auto; cout << Laster.Radlast(); cout << Motorrad.Gewicht(); cout << Ente; cout << Ente.Name(); } 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.

6 6 Die abgeleitete Klasse Auto (Deklaration) #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;} };

7 7 Die abgeleitete Klasse Laster (Deklaration) 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) {} double Effizienz () const { return _Ladung / (_Ladung + _Gewicht); } int Besatzung () const {return _Besatzung;} const char *Name () const { return "Lastwagen"; } int Fuehrerscheinklasse () const { return 2; } };

8 8 Anwendung der abgeleiteten Klassen int main() { Fahrzeug Hochrad(1, 5.7); cout << Hochrad; cout << Hochrad.Radlast(); Auto Ente(4, 700.0, 5); cout << Ente; cout << Ente.Passagiere() << Ente.Radlast() << Ente.Name(); Laster Sattelschlepper(18, , 1, ); cout << Sattelschlepper; cout << * Sattelschlepper.Effizienz() << Sattelschlepper.Name(); } return 0;

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

10 10 Konstruktoren/Destruktoren bei Vererbung 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; } };

11 11 Konstruktoren/Destruktoren bei Vererbung int main() { basis b; abgeleitet a; } Ausgabe Konstruktor fuer Klasse basis Konstruktor fuer Klasse basis Konstruktor fuer Klasse abgeleitet Destruktor fuer Klasse abgeleitet Destruktor fuer Klasse basis Destruktor fuer Klasse basis

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

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

14 14 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 {... };

15 15 Beispiel: Problem bei Verwendung von Zeigern 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; Ausgabe: Fahrzeug Fahrzeug Fahrzeug

16 16 Beispiel: Das gleiche Problem bei Vererbung class basis { public: void name() const { cout << "basis" << endl; } }; class abgeleitet : public basis { public: void name() const { cout << "abgeleitet" << endl; } }; void AusgabeName(const basis &b){ b.name(); }

17 17 Beispiel: Das gleiche Problem bei Vererbung int main() { basis b; abgeleitet a; cout << "Normale Ausgabe : " << endl; b.name(); a.name(); } cout << "Ausgabe ueber Funktion AusgabeName : " << endl; AusgabeName(b); AusgabeName(a); Ausgabe: Normale Ausgabe : basis abgeleitet Ausgabe ueber Funktion AusgabeName : basis basis

18 18 Beispiel: Ausweg durch virtuelle Funktionen class basis { public: virtual void name() const { cout << "basis" << endl; } }; class abgeleitet : public basis { public: void name() const { cout << "abgeleitet" << endl; } }; void AusgabeName(const basis &b){ b.name(); }

19 19 Beispiel: Ausweg durch virtuelle Funktionen int main() { basis b; abgeleitet a; cout << "Normale Ausgabe : " << endl; b.name(); a.name(); } cout << "Ausgabe ueber Funktion AusgabeName : " << endl; AusgabeName(b); AusgabeName(a); Ausgabe Normale Ausgabe : basis abgeleitet Ausgabe ueber Funktion AusgabeName : basis abgeleitet

20 20 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 zum einen redefiniert, zum anderen benutzen Pointer oder Referenzen auf die abgeleiteten Klassen, die auf die Basisklasse gecastet werden, dann auch die Elementfunktionen der abgeleiteten Klasse. Unser Beispielprogramm der Fuhrparks liefert jetzt das gewünschte Ergebnis: Fahrzeug Auto Lastwagen

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

22 22 Anmerkungen zu virtuellen Funktionen Virtuelle Funktionen sind Funktionen der Basisklasse, die in einer abgeleiteten Klasse 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(); Sobald polymorphe Objekte verwendet werden, sollten die Destruktoren virtuell sein: virtual Fahrzeug();

23 23 Beispiel: Abstrakte Deklaration der Klasse Fahrzeug 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; 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; };

24 24 Beispiel: Eine abstrakte Klasse // Vehikel Hochrad; // Verboten, da abstrakte Basisklasse Auto Ente(4, 700.0, 5); cout << Ente.Name() << Ente << Ente.Passagiere() << Ente.Radlast() << Ente.Fuehrerscheinklasse(); Laster Sattelschlepper(18, , 1, ); cout << Sattelschlepper.Name() << Sattelschlepper << * Sattelschlepper.Effizienz() << Sattelschlepper.Fuehrerscheinklasse(); Ausgabe: Auto 4 Raeder 700 kg 5 Passagiere 175 kg Klasse 3 Lastwagen 18 Raeder 5700 kg Prozent Klasse 2

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

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