17.04.2000 universität dortmund, lehrstuhl informatik 1 [email protected] eini ii...

17.04.2000

Universität Dortmund, Lehrstuhl Informatik [email protected]

EINI IIEinführung in die Informatik

für Naturwissenschaftler und Ingenieure II

Prof. Dr. Gisbert Dittrich

15-2

Prof. Dr. G. Dittrich17.04.2000

EINI II Kap. 15: Einführung in die Vererbung

Gliederung

• Ziele von Klassen (Wiederholung)

• Phänomene bei der elementaren Vererbung• Syntax• Überschreiben von Methoden

• Auflösung von Zirkularität

• Einführendes Beispiel: • string_Klasse, Woerter_Gross

• Beispiel: • Person, Mann, Frau

15-3



Ziele von Klassen

• Schon besprochen:• Kapselung von Attributen+Methoden (wie struct)• Erweiterte Möglichkeiten gegenüber struct

– Überladen von Funktionen– Konstruktoren– Destruktoren

• Neu:• Effiziente Wiederverwendbarkeit

– dazu:---> Vererbung

15-4



Neudefinition der Klasse?

• Bisherige Mittel zum Modellieren von „ähnlichen“ Klassen: • Neudefinition der Klasse

– z.B.: Code kann kopiert werden.

• Das ist nicht so gut:• langweilig,• fehleranfällig,• nicht änderungsfreundlich.

15-5



Alternative: Vererbung

Seien A und B Klassen.

• A ist Oberklasse von B (B ist Unterklasse von A)• --> B „erbt“ Attribute und Methoden von A,

d.h. B „kennt“ Attribute und Methoden von A.

(Wie genau, wird im folgenden detailliert angegeben.)

• B fügt neue Attribute und Methoden zu denen von A hinzu, ggf. werden (alte) Methoden neu definiert.

• Jede Instanz von B ist auch Instanz von A.

15-6



Beispiel: String - Nur Großbuchstaben

• Definiere String als Klasse:• string_Klasse:

– Attribute: Zeichenkette, Länge– Methoden: Konstruktor, Destruktor, Lies, Schreibe

• Betrachte „Unterklasse“ • Woerter_Gross:

Für Zeichenketten, die Buchstaben nur als Großbuchstaben aufweisen.

15-7



string_Klasse 1. Versuch

class string_Klasse {private:

char * s; int laenge;

public:string_Klasse(char *);~string_Klasse();bool lies(char *);void schreib();char * dieKette();int DieLaenge();

};Nicht gut: siehe später !

15-8



public besagtan dieser Stelle: Übernahme der Zugriffspezifikationenvon string_Klasse in die neue Klasse.

die Klasse Woerter_gross erbt von der Klasse string_Klasse:Attribute und Methoden von String_Klasse sind in Woerter_Gross verfügbar.

Grundansatz Vererbung

class Woerter_Gross:public string_Klasse

15-9



Grundansatz Vererbung

class Woerter_Gross:public string_Klasse {public:

Woerter_Gross(char *);void schreib();

};

15-10



Verfeinerung des Grundansatzes

• 2 Arten des Verbergens:• Geheimnis (auch) vor den Kindern:

– A möchte Eigenschaften für sich behalten und nicht beim Vererben weitergeben:

– --> Wahl der Zugriffsspezifikation private• Familiengeheimnisse:

– Attribute und Methoden werden nur Erben bekannt gemacht, nicht aber Außenstehenden:

– --> Wahl der Zugriffsspezifikation protected

15-11



„Modifikation“ von string_Klasse

class string_Klasse {protected:



};

steht also für dieErben (und nur

für sie) zur Verfügung

15-12



Zusammenfassung

• Alle als public oder protected zugreifbaren Komponenten sind für die Erben sichtbar. • Die als private charakterisierten Komponenten sind in ihrer Sichtbarkeit auf die Klasse selbst beschränkt.

15-13



privateZugriff nur innerhalb

der Klasse

protectedZugriff nur innerhalb

der Klasseund ihrer Erben

publicKomponente ist

öffentlichzugänglich

Zugriffsspezifikation

Klassifikationshierarchie

15-14



Neuer Konstruktor: Heißt ja

wie die Klasse

class Woerter_Gross : publicpublic string_Klasse {public:

Woerter_Gross(char *);void schreib();

};

public besagt hier: Die Zugriffs-spezifikationen für die Komponenten bleiben beim Erben erhalten

15-15



Konstruktor für Woerter

Woerter_Gross::Woerter_Gross(char * t) : string_Klasse(t) {

for (int i=0; i < laenge ; i++)if (islower(s[i]))

s[i] = toupper(s[i]);}

Zugriff auf den Konstruktor der

Oberklasse string

Zugriff auf das Attribut laengeder Oberklasse

15-16



Anmerkung

• Effekt des Konstruktors (im Beispiel): • Es wird ein Objekt vom Typ Woerter_Gross geschaffen; die Buchstaben der initialisierenden Zeichenkette sind Großbuchstaben.• Der erste Schritt bei der Erzeugung des Objekts besteht im Aufruf des Konstruktors für die Vaterklasse (Syntax!).

15-17



Redefinition einer Methode

Die Methode schreib wird neu definiert (redefiniert, überschrieben); dabei wird die Methode der Vaterklasse verwendet.

void Woerter_Gross::schreib(){cout << “Ueberschriebene Methode "

<< "(Achtung)\t\t";string_Klasse::schreib();}

15-18



/* Woerter_Gross,* Vorlage EED, EINI II, * SS 99, überarbeitet GD 8.4.2000* demonstriert Vererbung (einfach)*/

#include <iostream.h>

// verwendete Funktionsprototypen:void strcpy(char * nach, char * von);int strlen(char * r);bool islower(char c);char toupper(char c);

15-19



/* Woerter_Gross, Fortsetzung 1 */

class string_Klasse {protected:



};

15-20




string_Klasse::string_Klasse (char *t) {int lgth = strlen(t);s = new char[lgth+1];strcpy(s, t);laenge = --lgth;// sonst letztes Zeichen '\0'// mitgezählt}

string_Klasse::~string_Klasse() {laenge = -1;delete &s;}

15-21




bool string_Klasse::lies(char * r) {int strlen(char *);if (strlen(r) <= laenge+1) {

laenge = strlen(r);strcpy(s, r);return true; }

elsereturn false;

}

void string_Klasse::schreib() {cout << s << endl;}

15-22




char * string_Klasse::dieKette() {return s;}

int string_Klasse::DieLaenge() {return laenge;}

class Woerter_Gross:public string_Klasse {

public:Woerter_Gross(char *);void schreib();

};

15-23




Woerter_Gross::Woerter_Gross(char * t):

string_Klasse(t) {for (int i=0; i < laenge ; i++)

if (islower(s[i])) s[i] = toupper(s[i]);

}

void Woerter_Gross::schreib(){cout << "Ueberschriebene Methode "

<< "(Achtung)\t\t";string_Klasse::schreib();}

15-24




int main() {string_Klasse *s =

new string_Klasse ("aBra");s->schreib();s->~string_Klasse();Woerter_Gross * grS =

new Woerter_Gross("abra");grS->schreib();cout << "Laenge: "

<<grS->DieLaenge();return 0;

} Woerter_Gross

15-25




void strcpy(char * nach, char * von) {while (*nach++ = *von++);

}

int strlen(char * r) {int f = 0;while (r[f++]);return f;}

15-26




bool islower(char c) {if (('a' <= c) && (c <= 'z'))

return true;else

return false;}

char toupper(char c) {if (islower(c))

return (c - 'a' + 'A');else

return c;}

15-27



Woerter_Gross Ausgabe

aBra

Ueberschriebene Methode (Achtung) ABRA

Laenge: 4

15-28



Zusammenfassung

• Klasse Woerter_Gross ist Spezialfall der Klasse string_Klasse • (Wörter enthalten nur Großbuchstaben).

• Erbende Klasse kann auf alle nicht als private gekennzeichneten Komponenten zugreifen.• Die Zugriffsspezifikation protected wurde eingeführt, um den Zugriff angemessen zu regeln

15-29



Zusammenfassung

• Ein neuer Konstruktor mußtemußte definiert werden (anderer Name):• Der Konstruktor der Oberklasse kann verwendet werden.

• Eine Methode wurde redefiniert • Hierbei wurde auch die gleichnamige Methode des Vaters verwendet.

• Die Syntax hierfür wurde eingeführt.

15-30



FrauFrau MannMann

PersonPerson

Beispiel: Männer und Frauen

Gemeinsame Eigenschaften: • Name (Beschränkung auf Vornamen), • Vater, • Mutter. • --> Oberklasse: Person

– Obige Eigenschaften dort formulieren

15-31



class Person {private:

string * Vorname;Frau * Mutter;Mann * Vater;

public:Person(char *);Person(string *);~Person();string * DerVorname();void SetzeMutter(Frau *);void SetzeVater(Mann *);void Druck(char *);

};

gemeinsame Eigenschaften

gemein-same

Methoden

15-32



Anmerkung

• Gemeinsame Eigenschaften private• --> von außen nicht zugreifbar. • Auch von Erben nicht:

– sonst als protected vereinbart.

15-33



Modellierung der Klasse Frau

• Konstruktor (aus Namen und aus Person),• hat Ehemann, • heiratet,• ist Ehefrau von.

class Frau: public Person {private:

Mann * Ehemann;public:

Frau(char *);Frau(Person *);void NimmZumManne(Mann *);Mann * EhefrauVon();

};

15-34



Analog: Modellierung Klasse Mann

• Konstruktor (aus Namen und aus Person),• hat Ehefrau, • heiratet,• ist Ehemann von.

class Mann: public Person {private:

Frau * Ehefrau;public:

Mann(char *);Mann (Person *);void NimmZurFrau(Frau *);Frau * EhemannVon();

};

15-35



Problem: Zirkularität

Person • erfordert die Kenntnis von Frau, Mann,

Mann • erfordert die Kenntnis von Person, Frau,

Frau • erfordert die Kenntnis von Person, Mann.

(Erinnert an forward in Pascal.)

15-36



Lösung

Deklaration sieht im Programm so aus:

class Mann;class Frau;class Person { ... }; class Frau: public Person { ... };class Mann: public Person { ... };

Dann erst folgen die Definitionen der Methoden.

hier werdendie Namen

bekanntgemacht

15-37



Konstruktoren für Klasse Person

Konstruktoren für die Klasse sind überladen, einmal Zeichenkette, dann string als Parameter.

Person::Person(char * v) {Vorname = new string(v);Vater = NULL;Mutter = NULL;}

Person::Person(string * s) {Vorname = s;Vater = NULL;Mutter = NULL;}

15-38



Weitere Methoden

Destruktor: • Ruft nur den Destruktor für die Zeichenkette auf

Person::~Person() {Vorname->~string();}

Die anderen Methoden (bis evtl. auf Druck) sollten klar sein. Die Methode Druck druckt den Vornamen aus und ruft ggf. die Druck-Methode für Vater und für Mutter auf.

15-39



void Person::Druck(char * s) {cout << s

<< "(Vorname) " << Vorname->dieKette() << endl;

if(Mutter != NULL) {cout << "\nDaten der Mutter:\n";Mutter->Druck("");}

if(Vater != NULL) {cout << "\nDaten des Vaters:\n ";Vater->Druck("");}

};

15-40



Bemerkenswert

• Aufrufe • Vater->Druck() und Mutter->Druck()benutzen die Tatsache, daß Vater und Mutter auch vom Typ Person sind.• In den Klassen Mann oder Frau sind keine neuen Methoden Druck vereinbart!

• Dies deutet an: • Vererbung erlaubt flexible Modellierung und Programmierung.

15-41



Konstruktoren und Methoden für die Klasse Mann

Mann::Mann(char * v) :Person(v) {Ehefrau = NULL;}

Mann::Mann(Person *p) : Person(p->DerVorname()){

Ehefrau = NULL;}

void Mann::NimmtZurFrau(Frau * thisLady) {Ehefrau = thisLady;}

Frau * Mann::EhemannVon(){return Ehefrau;}

15-42



Heiratsroutine

void Verheirate(Mann * m, Frau * f){m->NimmZurFrau(f);f->NimmZumManne(m);}

Bemerkenswert: steht außerhalb der Klassendefinitionen.

15-43



int main() {Mann * Adam = new Mann("Adam");Frau * Eva = new Frau("Eva");Mann * Kain = new Mann("Kain");Kain->SetzeMutter(Eva); Kain->SetzeVater(Adam);Mann * Abel = new Mann("Abel");Abel->SetzeMutter(Eva); Abel->SetzeVater(Adam);Adam->Druck("Zu Adam: ");

Eva->Druck("\nZu Eva:");Kain->Druck("\n\nAngaben zu Kain:");Abel->Druck("\n\nAngaben zu Abel:");Verheirate(Adam, Eva);cout << "\nverheiratet?\n";Eva->EhefrauVon()->

Druck("\tEva ist verheiratet mit:\n");Adam->EhemannVon()->

Druck("\tAdam ist verheiratet mit :\n ");return 0;}

Mann-Frau

15-44



Mann-Frau: AusgabeZu Adam: (Vorname) Adam

Zu Eva: (Vorname) Eva

Angaben zu Kain: (Vorname) Kain

Daten der Mutter: (Vorname) Eva

Daten des Vaters: (Vorname) Adam

Angaben zu Abel: (Vorname) Abel

Daten der Mutter: (Vorname) Eva

Daten des Vaters: (Vorname) Adam

verheiratet?

Eva ist verheiratet mit:

(Vorname) Adam

Adam ist verheiratet mit:

(Vorname) Eva (umformatiert: GD)

15-45



// Personen mit Unterklassen// Vorlage EED EINI II, SS 99, prog-27a; // Überarbeitet: GD 14.4.00// demonstriert Vererbung//

#include <iostream.h>#include <stdio.h>#include "clstring.h"

class Mann;class Frau;void Verheirate(Mann *, Frau *);

15-46



// Personen mit Unterklassen, Fortsetzung 1

class Person {private:

stringcl * Vorname;Frau * Mutter;Mann * Vater;

public:Person(char *);Person(stringcl *);~Person();stringcl * DerVorname();void SetzeMutter(Frau *);void SetzeVater(Mann *);void Druck(char *);

};

15-47




class Frau: public Person {private:

Mann * Ehemann; public:

Frau(char *);Frau (Person *);void NimmZumManne(Mann *);Mann * EhefrauVon();};

class Mann: public Person {private:

Frau * Ehefrau; public:

Mann(char *);Mann (Person *);void NimmZurFrau(Frau *);Frau * EhemannVon();};

15-48




Person::Person(char * v) {Vorname = new stringcl(v);Vater = NULL; Mutter = NULL;}

Person::Person(stringcl * s) {Vorname = s;Vater = NULL; Mutter = NULL;}

Person::~Person() {Vorname->~stringcl();}

stringcl * Person::DerVorname() {return Vorname;}

void Person::SetzeMutter(Frau * Mom) {Mutter = Mom;}

void Person::SetzeVater(Mann * Dad) {Vater = Dad;}

15-49




void Person::Druck(char * s) {cout << s << "\t(Vorname) " << Vorname->dieKette() << endl;if(Mutter != NULL) { cout << "\nDaten der Mutter: " << endl;

Mutter->Druck("");}if(Vater != NULL) { cout << "\nDaten des Vaters: " << endl;

Vater->Druck("");}};

Frau::Frau(char * v) :Person(v) {Ehemann = NULL;}

Frau::Frau(Person *p) :Person(p->DerVorname()){Ehemann = NULL;}

15-50




void Frau::NimmZumManne(Mann * erDa) {Ehemann = erDa;}

Mann * Frau::EhefrauVon(){return Ehemann;}

Mann::Mann(char * v) :Person(v) {Ehefrau = NULL;}

Mann::Mann(Person *p) :Person(p->DerVorname()){Ehefrau = NULL;}

void Mann::NimmZurFrau(Frau * thisLady) {Ehefrau = thisLady;}

15-51




Frau * Mann::EhemannVon(){return Ehefrau;}

void Verheirate(Mann * m, Frau * f){m->NimmZurFrau(f);f->NimmZumManne(m);}

int main() {Mann * Adam = new Mann("Adam");Frau * Eva = new Frau("Eva");Mann * Kain = new Mann("Kain");Kain->SetzeMutter(Eva);Kain->SetzeVater(Adam);

15-52



// Personen mit Unterklassen, Fortsetzung 7//int main() {Fortsetzung !!!!

Mann * Abel = new Mann("Abel");Abel->SetzeMutter(Eva);Abel->SetzeVater(Adam);Adam->Druck("Zu Adam: ");Eva->Druck("\nZu Eva:");Kain->Druck("\n\nAngaben zu Kain:");Abel->Druck("\n\nAngaben zu Abel:");Verheirate(Adam, Eva);cout << "\nverheiratet?\n";Eva->EhefrauVon()->Druck("\tEva ist

verheiratet mit: \n");Adam->EhemannVon()->Druck("\tAdam ist

verheiratet mit: \n");return 0;}

15-53



// Hilfsklasse stringcl in Datei "clstring.h"// Vorlage EED EINI II SS99, // überarbeitet GD 9.4.00

void strcpy(char * nach, char * von);int strlen(char * r);bool islower(char c);char toupper(char c);

void strcpy(char * nach, char * von) {while (*nach++ = *von++);}

int strlen(char * r) {int f = 0;while (r[f++]);return f;}

15-54



// Hilfsklasse stringcl, Fortsetzung 1

bool islower(char c) {if (('a' <= c) && (c <= 'z'))

return true;else

return false;}

char toupper(char c) {if (islower(c))

return (c - 'a' + 'A');else

return c;}

15-55




class stringcl {protected:


public:stringcl(char *);~stringcl();bool lies(char *);void schreib();char * dieKette();int DieLaenge();

};

15-56




stringcl::stringcl (char *t) {int lgth = strlen(t);s = new char[lgth+1];strcpy(s, t);laenge = --lgth;}

stringcl::~stringcl() {laenge = -1; delete &s;}

bool stringcl::lies(char * r) {int strlen(char *);if (strlen(r) <= laenge) {

laenge = strlen(r);strcpy(s, r);return true;}

else return false;}

15-57




void stringcl::schreib() {cout << s << endl;}

char * stringcl::dieKette() {return s;}

int stringcl::DieLaenge() {return laenge;}

17.04.2000 universität dortmund, lehrstuhl informatik 1 [email protected] eini ii...

Documents