11 Vererbung und Klassenhierarchie

Transkript

1 11 Vererbung und Klassenhierarchie Bestandteile objektorientierter Programmierung: Bestehende Klassen können durch Spezialisierung und Erweiterung weiterentwickelt werden, ohne den Programmcode der alten Klassen verändern zu müssen Vererbung Dadurch erspart man sich zunächst einmal, bestehenden Programmcode neu zu schreiben oder zu duplizieren. Statt dessen schreibt man eine neue Klasse und gibt bei der Beschreibung an, von welcher bestehenden Klasse ausgegangen werden soll (Ableiten aus dieser Klasse). Die neue Klasse erbt Methoden und Attribute der alten Klasse (Basisklasse) und kann zusätzlich durch neue ergänzt werden bzw. Methoden der alten Klasse können umdefiniert werden. Die Idee, Klassenhierarchieen aufzubauen, sollte aber nicht allein dazu dienen, Schreibweisen zu vereinfachen, sondern konzeptionelle Ideen von Programmdesign umsetzen. Im wesentlichen bedeutet das für uns, daß die Sprachmechanismen von C++ dazu genutzt werden sollen, Gemeinsamkeiten zwischen Klassen auszudrücken. WS 2001/02 Programmierkurs C++ Seite 174

2 Beispiel: Das Konzept eines Kreises und eines Dreiecks stehen in Beziehung zueinander. Beides sind Formen. Bei der Darstellung von Kreisen und Dreiecken in einem Programm, ohne die Notation einer Form einzuführen, fehlt etwas Ableitung einer Klasse Beispiel: Angestellte einer Firma. Betrachte zunächst nur Datensammlung. struct Employee{ string first_name, family_name; short department; struct Manager{ Employee emp; // employee data list<employee*> group; // group managed short level; Beziehung der Objekte: Ein Manager ist ein Angestellter: die Daten Employee stehen im Member emp von Manager. Ein Angestellter ist nicht unbedingt ein Manager. WS 2001/02 Programmierkurs C++ Seite 175

3 aber: Es gibt nichts, was dem Kompiler diese Beziehung mitteilt. Manager* ist nicht ein Employee*, so daß man nicht einfach einen Manager dort verwenden kann, wo ein Employee gefragt ist (obwohl man dies gerne würde). Insbesondere läßt sich so keine Liste von Angestellten erstellen, die auch Manager enthält. Mechanismus der Vererbung: struct Manager : public Employee{ list<employee*> group; short level; // group managed Manager ist von Employee abgeleitet. Employee ist Basisklasse für Manager. Manager besitzt alle Member von Employee plus zusätzlich eigenen. Manager kann so auch überall dort verwendet werden, wo ein Employee erlaubt ist. WS 2001/02 Programmierkurs C++ Seite 176

4 void f(manager m1, Employee e1) { list<employee*> emplist; emplist.push_front(&m1); emplist.push_front(&e1); (Hinweis: list<> sei eine Listenstruktur von Zeigern auf Employee, in die über die Methode push_front() Elemente vorne eingefügt werden können.) Die Ableitung mittels des Schlüsselworts public von Manager von Employee kann gelesen werden als: Manager ist ein Employee Das Objekt einer abgeleiteten Klasse kann deshalb wie ein Objekt der Basisklasse behandelt werden, wenn es über Zeiger und Referenzen manipuliert wird. Die Umkehrung hiervon ist ungültig: void g(manager m, Employee e) { Employee* pe = &m; // o.k. Manager* pm = &e; // error pm->level = 2; // error pm = static_cast<manager*>(pe); // erlaubt pm->level = 2; // jetzt o.k. WS 2001/02 Programmierkurs C++ Seite 177

5 Employee* pe = &m; Ein Manager ist ein Employee. Keine explizite Typumwandlung notwendig. Manager* pm = &e; Verboten: Nicht jeder Employee ist ein Manager... pm->level = 2; denn dann würde ein solcher Aufruf zu einem Programmabsturz führen, da e kein Member level besitzt! pm = static_cast<manager*>(pe); Eine explizite Typumwandlung ist aber möglich. In diesem Falle führt dies auch zu einem sinnvollen Ergebnis, da pe auf ein Objekt Manager zeigt. Der Compiler vertraut hier dem Programmierer! pm->level = 2; Funktioniert in diesem Falle, da pm auf ein Objekt Manager zeigt Memberfunktionen und Zugriff Betrachten wir jetzt wieder selbstdefinierte Datentypen, die auch Methoden besitzten. WS 2001/02 Programmierkurs C++ Seite 178

6 class Employee{ private: string first_name, family_name; void print() const; string full_name() const {return first_name+ +family_name; class Manager : public Employee{ privat: void print() const; Die Unterklasse erbt, die vererbende Klasse hat keinen Einfluß darauf, welche Klasse von ihr erbt. : public kann gelesen werden als ist ein. Jede öffentliche Methode der Basisklasse kann innerhalb der Unterklasse verwendet werden: void Manager::print() const { cout << "Name: " << full_name() << endl; WS 2001/02 Programmierkurs C++ Seite 179

7 Manager mgr; Jede öffentliche Methode der Basisklasse kann auf die Objekte der Unterklasse angewandt werden: cout «mgr.full_name() «endl; Der Aufruf läßt nicht erkennen, ob eine Methode in der Basis- oder Unterklasse vereinbart worden ist. Aber: Der Zugriff auf die privaten Teile der Basisklasse Employee ist von der Unterklasse nicht möglich. Folgende Version von Manager::print(): void Manager::print() const { cout << "Name: " << family_name << endl; führt zu der Compilermeldung: In method void Manager::print() const : class string Employee::family_name is private within this context Sinnvoll, denn würde man generell allen abgeleiteten Klassen den Zugriff auf private Member erlauben, könnte man den Schutz durch Erzeugung abgeleiteter Klassen durchbrechen. WS 2001/02 Programmierkurs C++ Seite 180

8 Mögliche Lösung: Man könnte das Attribut family_name öffentlich machen. Dadurch hätte aber auch jede andere Klasse Zugriff auf dieses Datenmember. Dies widerspricht der Idee der Datenkapselung. Lösung C++ Neben public und private existiert ein weiterer Zugriffs Modus protected. Auf protected Member kann nur zugegriffen werden: von der eigenen Klasse aus abgeleiteten Klassen class Employee{ protected: string first_name, family_name; class Manager : public Employee{ void print() const; WS 2001/02 Programmierkurs C++ Seite 181

9 Methoden und Für die :public :protected :private Attribute sind Benutzung der für die für die für die in Basisklasse Basisklasse : Unterklasse Unterklasse Unterklasse definiert als: gilt: gilt: gilt: gilt: nicht nicht nicht nicht sichtbar sichtbar sichtbar sichtbar sichtbar private private private private nicht sichtbar sichtbar sichtbar sichtbar sichtbar protected protected protected private sichtbar sichtbar sichtbar sichtbar public public protected private WS 2001/02 Programmierkurs C++ Seite 182

10 Die Zugriffsrechte zwischen den Klassen lassen sich darüber hinaus stärker beschränken und spezifiziern, indem man angibt, wie man von der Basisklasse ableiten möchte. Auf alle Elemente der Basisklasse kann in der neuen Klasse nur noch höchstens so wie angegeben zugegriffen werden: Es ist auch möglich (und im Sinne der Datenkapselung konsequenter), daß man lediglich öffentliche Member der Basisklasse zur Verwendung zulassen möchte: void Manager::print() const { Employee::print(); // print Employee cout << level; // print specific data Der Operator zur Auflösung von Namen :: ist hier sehr wichtig, da sich der Aufruf der Methode print() sonst auf Manager beziehen würde. Es würde eine Endlos Schleife resultieren. WS 2001/02 Programmierkurs C++ Seite 183

11 Abstraktes Beispiel zu Sichtbarkeiten und Zugriffsrechten class Ober{ void pubm(); protected: void protm(); long prota; private: void PrivM(); long priva; Ableitung eine Unterklasse über class Unter : public Ober{ void unterm(){ pubm(); protm(); prota = 5; privm(); // FEHLER!!! priva = 5; // FEHLER!!! Sei u ein Objekt der Klasse Unter: Unter u; u.pubm(); // ERLAUBT u.protm(); // FEHLER!!! WS 2001/02 Programmierkurs C++ Seite 184

12 Die Sichtbarkeit protected fügt eine notwendige Ebene zwischen public und private ein. protected Eigenschaft kann auch an weitere Erben übergeben werden. In class Unter2 : public Unter... ist protm() sichtbar. Erben als private oder protected ermöglicht das Verbergen der Ahnen : class Unter : private Ober {... u.unterm(); // ERLAUBT u.pubm(); // FEHLER!!! Verborgen Methoden können auch wieder sichtbar gemacht werden. Dazu muß eine neue Methode als Hülle um die verborgene Methode im public Bereich gebaut werden: void PrivM_Neu(){ PrivM(); Konstruktoren und Destruktor Die Initialisierung der Klassenmember muß über einen Konstruktor erfolgen, da von außen kein Zugriff auf die privaten Member der Klasse besteht. Zudem wird dieser automatisch aufgerufen, sobald ein Objekt der Klasse erzeugt wird. WS 2001/02 Programmierkurs C++ Seite 185

13 Konstruktor: class Employee{ Employee(string&,string&,short); class Manager : public Employee{ Manager(string&,string&,short,short); Objekte einer Klasse werden in der Reihenfolge der Ableitung aufgebaut, d.h. bei Erzeugung eines Objekts Manager wird zuerst der Konstruktor von Employee aufgerufen. Die Argumente der Basisklasse werden in der Definition der Unterklasse angegeben. Benötigt der Konstruktor der Basisklasse Argumente, dann sollte dieser Konstruktor explizit im Konstruktor der Unterklasse aufgerufen werden. Ein Konstruktor einer abgeleiteten Klasse kann keine Member der Basisklasse direkt im Konstruktorkopf initialisieren. WS 2001/02 Programmierkurs C++ Seite 186

14 FALSCH: Manager::Manager(string& n1,string& n2, { short dep,short lev) : first_name(n1), family_name(n2), RICHTIG: department(dep), level(lev) Manager::Manager(string& n1,string& n2, { short dep,short lev) : Employee(n1,n2,dep), // init base Destruktor: level(lev) // init members Wird ein Objekt zerstört, dann geschieht dies in der umgekehrten Reihenfolge des Aufbaus. Zunächst die abgeleitete Klasse, dann ihre Member und zuletzt die Basisklasse. Mehr im folgenden Unterkapitel... WS 2001/02 Programmierkurs C++ Seite 187