Einführung in die Programmierung

Transkript

1 : Klassen Inhalt Einführung in die Programmierung Wintersemester 2008/09 Prof. Dr. Günter Rudolph Lehrstuhl für Algorithm Engineering Fakultät für Informatik TU Dortmund Einführung Konstruktoren / Destruktoren Kopierkonstruktor Selbstreferenz Überladen von Operatoren 2 : Klassen : Klassen Ziele von Klassen Schlüsselwort: class Kapselung von Attributen (wie struct in Programmiersprache C) Kapselung von klassenspezifischen Funktionen / Methoden Effiziente Wiederverwendbarkeit - Vererbung - Virtuelle Methoden Grundlage für Designkonzept für Software Datentypdefinition / Klassendefinition analog zu struct struct Punkt { ; ; Unterschied: Punkt p; p.x = 1.1; p.y = 2.0;? Punkt p; p.x = 1.1; p.y = 2.0; Zugriff gesperrt! 3 4 1

2 : Klassen : Klassen Schlüsselwort: class Datentypdefinition / Klassendefinition analog zu struct struct Punkt { ; Komponenten sind öffentlich! (public) ; Komponenten sind privat! (private) Kontrolle über Zugriffsmöglichkeit sollte steuerbar sein! Man benötigt Mechanismus, um auf Komponenten zugreifen zu können! 5 prozedural struct Punkt { ; void SetzeX(Punkt &p, double w); void SetzeY(Punkt &p, double w); double LeseX(Punkt &p); double LeseY(Punkt &p); objekt-orientiert void SetzeX(double w); void SetzeY(double w); double LeseX(); double LeseY(); ; Schlüsselwort public : alles Nachfolgende ist öffentlich zugänglich! 6 : Klassen : Klassen struct Punkt { ; void Verschiebe(Punkt &p, double dx, double dy); bool Gleich(Punkt &a, Punkt& b); double Norm(Punkt &a); void SetzeX(double w); void SetzeY(double w); double LeseX(); double LeseY(); void Verschiebe(double dx, double dy); bool Gleich(Punkt &p); double Norm(); ; 7 void SetzeX(double w) { x = w; void SetzeY(double w) { y = w; double LeseX() { return x; double LeseY() { return y; void Verschiebe(double dx, double dy); bool Gleich(Punkt &p); double Norm(); ; Implementierung: direkt in der Klassendefinition void Punkt::Verschiebe(double dx, double dy) { x += dx; Implementierung: y += dy; außerhalb der Klassendefinition 8 2

3 : Klassen : Klassen Prinzip des information hiding Datei: Punkt.h Trennung von Klassendefinition und Implementierung am besten in verschiedenen Dateien! Punkt.h Punkt.cpp Klassendefinition Klassenimplementierung *.h header *.cpp cplusplus bei Implementierung außerhalb der Klassendefinition: Angabe des Klassennames nötig! Datentyp Klassenname::Methode( ){ 9 void SetzeX(double w); void SetzeY(double w); double LeseX(); double LeseY(); void Verschiebe(double dx, double dy); bool Gleich(Punkt &p); double Norm(); ; Die Klassendefinition wird nach außen (d.h. öffentlich) bekannt gemacht! Die Implementierung der Methoden wird nach außen hin verborgen! 10 : Klassen : Klassen Datei: Punkt.cpp #include <math.h> #include "Punkt.h" void Punkt::SetzeX(double w) { x = w; void Punkt::SetzeY(double w) { y = w; double Punkt::LeseX() { return x; double Punkt::LeseY() { return y; void Punkt::Verschiebe(double dx, double dy) { x += dx; y += dy; bool Punkt::Gleich(Punkt &p) { return x == p.lesex() && y == p.lesey()? true : false; double Punkt::Norm() { return sqrt(x * x + y * y); 11 Überladen von Methoden bool Gleich(Punkt &p); bool Gleich(double ax, double ay) { return (x == ax && y == ay)? true : false; ; mehrere Methoden mit gleichem Namen wie unterscheidbar? durch ihre verschiedenen Signaturen / Argumentlisten! Punkt p1, p2; // if (p1.gleich(p2) p1.gleich(1.0, 2.0)) return; 12 3

4 : Klassen : Klassen Initialisierung umständlich: Aufgaben eines Konstruktors: Punkt p; p.setzex(1.3); p.setzey(2.9);? wie bei struct Punkt? Punkt p = { 1.3, 2.9 ; Saubere Initialisierung eines Objekts man kann erzwingen, dass nur initialisierte Instanzen erzeugt werden ggf. Bereitstellung von dynamischen Speicherplatz Konstruktoren Punkt() { x = y = 0.0; Punkt(double ax, double ay) { x = ax; y = ay; ;! identisch zu: Punkt p1(0,0); Punkt p1; Punkt p2(1.3, 2.9); ggf. Benachrichtigung eines anderen Objekts über Erzeugung (Registrierung) durch Überladen: bequeme Möglichkeiten zur Initialisierung Bsp: Default-Werte Punkt(); z.b. wie Punkt(0.0, 0.0) Punkt(double x); z.b. wie Punkt(x, 0.0); Punkt(double x, double y); was immer gerade nötig ist : Klassen : Klassen Merke: Instanzen von Klassen können auch dynamisch erzeugt werden: Konstruktoren heißen exakt wie die Klasse, zu der sie gehören! Wenn eine Instanz einer Klasse angelegt wird automatischer Aufruf des Konstruktors! Da nur Instanz angelegt wird (Speicherallokation und Initialisierung) wird kein Wert zurückgegeben kein Rückgabewert (auch nicht void) Konstruktoren können überladen werden bei mehreren Konstruktoren wird der ausgewählt, der am besten zur Signatur / Argumentliste passt eindeutig! Punkt *p1 = new Punkt(2.1, 3.3); Punkt *p2 = new Punkt(); Punkt *p3 = new Punkt; Achtung! Das Löschen nicht vergessen! Speicherplatzfreigabe! delete p1; etc. gleichwertig!

5 : Klassen : Klassen Destruktoren dual zu Konstruktoren automatischer Aufruf, wenn Instanz Gültigkeitsbereich verlässt heißen exakt wie die Name der Klasse, zu der sie gehören Unterscheidung von Konstruktoren bzw. Kennzeichnung als Destruktor durch vorangestellte Tilde ~ Bsp: ~Punkt(); Destruktoren haben niemals Parameter Zweck: Aufräumarbeiten - z.b. Schließen von Dateien - z.b. Abmeldung bei anderen Objekten (Deregistrierung) - z.b. Freigabe von dynamischen Speicher, falls vorher angefordert - und was immer gerade nötig ist 17 Illustration: Punkt::Punkt(double ax, double ay) { x = ax; y = ay; cout << Konstruktor aufgerufen! << endl; Punkt::~Punkt() { cout << Destruktor aufgerufen! << endl; int main() { cout << Start << endl; { Punkt p(1.0, 2.0); cout << Ende << endl; Ausgabe: Start Konstruktor aufgerufen! Destruktor aufgerufen! Ende 18 : Klassen : Klassen Noch ein Beispiel Großes Beispiel Punkt::Punkt(double ax, double ay) { x = ax; y = ay; cout << K: << x << << y << endl; Punkt::~Punkt() { cout << D: << x << << y << endl; int main() { cout << Start << endl; Punkt p1(1.0, 0.0); Punkt p2(2.0, 0.0); cout << Ende << endl; Ausgabe: Start K: K: Ende D: D: Konstruktoren: Aufruf in Reihenfolge der Datendefinition Destruktoren: Aufruf in umgekehrter Reihenfolge Punkt g1(-1.0, 0.0); Punkt g2(-2.0, 0.0); int main() { cout << "Main Start" << endl; Punkt q1(0.0, 1.0); { cout << "Block Start" << endl; Punkt p1(1.0, 0.0); Punkt p2(2.0, 0.0); Punkt p3(3.0, 0.0); cout << "Block Ende" << endl; Punkt q2(0.0, 2.0); cout << "Main Ende" << endl; Punkt g3(-3.0, 0.0);

6 : Klassen : Klassen int id; Punkt(); ~Punkt(); ; Punkt.h static int cnt = 1; Punkt::Punkt() : id(cnt++) { cout << "K" << id << endl; Punkt::~Punkt() { cout << "D" << id << endl; Punkt.cpp int main() { cout << "Start" << endl; { cout << "Block Start" << endl; Punkt menge[3]; cout << "Block Ende" << endl; cout << "Ende" << endl; return 0; Ausgabe: Hack! Nur für Demozwecke! Feld / Array Start Block Start K1 K2 K3 Block Ende D3 D2 D1 Ende 21 Regeln für die Anwendung für Konstruktoren und Destruktoren 1. Allgemein Bei mehreren globalen Objekten oder mehreren lokalen Objekten innerhalb eines Blockes werden - die Konstruktoren in der Reihenfolge der Datendefinitionen und - die Destruktoren in umgekehrter Reihenfolge aufgerufen. 2. Globale Objekte - Konstruktor wird zu Beginn der Lebensdauer (vor main) aufgerufen; - Destruktor wird hinter der schließenden Klammer von main aufgerufen. 3. Lokale Objekte - Konstruktor wird an der Definitionsstelle des Objekts aufgerufen; - Destruktor wird beim Verlassen des definierenden Blocks aufgerufen. 22 : Klassen : Klassen Regeln für die Anwendung für Konstruktoren und Destruktoren 4. Dynamische Objekte - Konstruktor wird bei new aufgerufen; - Destruktor wird bei delete für zugehörigen Zeiger aufgerufen. 5. Objekt mit Klassenkomponenten - Konstruktor der Komponenten wird vor dem der umfassenden Klasse aufgerufen; - am Ende der Lebensdauer werden Destruktoren in umgekehrter Reihenfolge aufgerufen. 6. Feld von Objekten - Konstruktor wird bei Datendefinition für jedes Element beginnend mit Index 0 aufgerufen; - am Ende der Lebensdauer werden Destruktoren in umgekehrter Reihenfolge aufgerufen. 23 Kopierkonstruktor (copy constructor) Punkt(double ax, double bx); Punkt(const Punkt& p); ~Punkt(); ; Punkt::Punkt(const Punkt& p) { x = p.x; y = p.y; Kann wie eine Zuweisung interpretiert werden! Kopierkonstruktor Entstehendes Objekt wird mit einem bestehenden Objekt initialisiert! alternativ: Punkt::Punkt(const Punkt& p) : x(p.x), y(p.y) { wirkt wie Zuweisung; geht nur bei Klassenelementen 24 6

7 : Klassen : Klassen Kopierkonstruktor (copy constructor) Bauplan: ObjektTyp (const ObjektTyp & bezeichner); Kopierkonstruktor liefert / soll liefern byteweises Speicherabbild des Objektes Wird automatisch aufgerufen, wenn: 1. ein neues Objekt erzeugt und mit einem bestehenden initialisiert wird; 2. ein Objekt per Wertübergabe an eine Funktion gereicht wird; 3. ein Objekt mit return als Wert zurückgegeben wird. Punkt a(1.2, 3.4); // Neu Punkt b(a); // Kopie Punkt c = b; // Kopie b = a; // Zuweisung! Was passiert, wenn ich keinen Kopierkonstruktor implementiere? 25 Kopierkonstruktor (copy constructor) Wird für eine Klasse kein Kopierkonstruktur implementiert, dann erzeugt ihn der Compiler automatisch! Achtung! Es wird dann ein byteweises Speicherabbild des Objektes geliefert! flache Kopie (engl. shallow copy) Problem: - Konstruktor fordert dynamischen Speicher an - Konstruktor öffnet exklusive Datei (o.a. Resource) dann tiefe Kopie (engl. deep copy) nötig! man muss Kopierkonstruktor (und Destruktor) implementieren! nur Kopie des Zeigers nicht teilbar! Crash! 26 : Klassen : Klassen Klassendefinition class CZeit { Default-Werte int mstd, mmin, msek; CZeit(); // Konstruktor CZeit(int std, int min = 0, int sek = 0); // Konstruktor CZeit(const CZeit& azeit); // Kopierkonstruktor void Anzeigen(); int Std(); int Min(); int Sek(); static CZeit Jetzt(); // statische Klassenfunktion ; CZeit addiere(czeit z1, CZeit z2); // globale Funktion 27 Konstruktoren CZeit::CZeit() : mstd(0), mmin(0), msek(0) { CZeit::CZeit(int astd, int amin, int asek) : mstd(astd), mmin(amin), msek(asek) { assert(mstd >= 0 && mstd < 24); assert(mmin >= 0 && mmin < 60); assert(msek >= 0 && msek < 60); CZeit::CZeit(const CZeit& azeit) : mstd(azeit.mstd), mmin(azeit.mmin), msek(azeit.msek) { statische Elementfunktion CZeit CZeit::Jetzt() { time_t jetzt = time(0); struct tm *hms = localtime(&jetzt); CZeit z(hms->tm_hour, hms->tm_min, hms->tm_sec); return z; 28 7

8 : Klassen : Klassen int CZeit::Std() { return mstd; int CZeit::Min() { return mmin; int CZeit::Sek() { return msek; void CZeit::Anzeigen() { cout << mstd << ':' << mmin << ':' << msek << endl; CZeit addiere(czeit z1, CZeit z2) { CZeit zeit; zeit.mstd = z1.mstd + z2.mstd; // usw CZeit addiere(czeit z1, CZeit z2) { int std = z1.std() + z2.std(); int min = z1.min() + z2.min(); int sek = z1.sek() + z2.sek(); CZeit zeit(std, min, sek); return zeit; ACHTUNG! Externer Zugriff auf private Daten! Zugriff gesperrt! Funktioniert so nicht! Hier muss noch dafür gesorgt werden, dass der Konstruktor keine Assertion wirft! 29 Verschönerung der Zeitanzeige bisher: CZeit z(12,5,34); z.anzeigen(); liefert Ausgabe: 12:5:34 void CZeit::Anzeigen() { cout << mstd << ':' << mmin << ':' << msek << endl; wir wollen haben: 12:05:34 void CZeit::Anzeigen() { if (mstd < 10) cout << "0"; cout << mstd << ":"; if (mmin < 10) cout << "0"; cout << mmin << ":"; if (msek < 10) cout << "0"; cout << msek << endl; liefert 12:05:34 30 : Klassen : Klassen Testprogramm Normalisierung #include <iostream> #include "CZeit.h" using namespace std; int main(){ CZeit z(czeit::jetzt()); z.anzeigen(); CZeit a(1,0,0); CZeit sum; sum = addiere(z, a); sum.anzeigen(); return 0; Ausgabe (z.b.): 14:45:21 15:45:21 schöner wäre ja: sum = z + a; Überladen von Operatoren! (später ) class CZeit { int mstd, mmin, msek; void normalize(); ; void CZeit::normalize() { mmin += msek / 60; msek %= 60; mstd += mmin / 60; mmin %= 60; mstd %= 24; Private Hilfsfunktion: kann nur innerhalb der Klassenimplementierung aufgerufen werden! setzt beliebige nichtnegative Werte auf normale Werte: 0 mstd < 24 0 mmin < 60 0 msek <

9 : Klassen : Klassen Konstruktor: 2. Version CZeit::CZeit(int astd, int amin, int asek) : mstd(astd), mmin(amin), msek(asek) { normalize(); Problem: negative Eingaben werden via normalize() nicht repariert Selbstreferenz class CZeit { CZeit& addstd(int n); CZeit& addmin(int n); CZeit& addsek(int n); Bsp: für 3. Version: unsigned int CZeit x = CZeit::Jetzt(); CZeit z = x.addstd(1).addmin(21); Konstruktor: 3. Version CZeit::CZeit( unsigned int astd, unsigned int amin, unsigned int asek ) : mstd(astd), mmin(amin), msek(asek) { normalize(); Lösung: nichtnegative Eingaben erzwingen via unsigned int in Argumentliste des Konstruktors CZeit& addmin(int n) { mmin += n; normalize(); return *this; Schlüsselwort: this this ist Zeiger auf das Objekt, für das die Elementfunktion aufgerufen wurde. *this bezieht sich auf das Objekt selbst : Klassen : Klassen Überladen von Operatoren Überladen von Operatoren Operator ist eine Verknüpfungsvorschrift! Welche? Kann man auffassen als Name einer Funktion: + ^ == += ^=!= << () Bsp: Addition a + b interpretieren als + (a, b) in C++ als: c = operator+ (a, b) - * & > >= -= *= &= = && <<= >> new delete Funktionsname Argumente Zweck: eine Klasse mit Funktionalität ausstatten, die vergleichbar mit elementarem Datentyp ist! Vorteil: Quellcode wird übersichtlicher / ~ < /= ++ %! <= %= -- Wie? Objekttyp& operator (const ObjektTyp& bezeichner) Objekttyp operator (const ObjektTyp& bezeichner) -> ->* >>= [] =

10 : Klassen : Klassen Überladen von Operatoren bool operator== (const CZeit& azeit) { if (azeit.mstd!= Std()) return false; if (azeit.mmin!= Min()) return false; if (azeit.msek!= Sek()) return false; return true; CZeit& operator= (const CZeit& azeit) { mstd = azeit.mstd; mmin = azeit.mmin; msek = azeit.msek; return *this; Test auf Gleichheit Zuweisung Wenn für eine Klasse der Zuweisungsoperator nicht überschrieben wird, dann macht das der Compiler automatisch! Vorsicht! Speicher des Objektes wird byteweise überschrieben! Problem: z.b. wenn Objekt dynamischen Speicher verwendet gleiche Problematik wie beim Kopierkonstruktor Merke: Wenn die Implementierung eines Kopierkonstruktors nötig ist, dann höchstwahrscheinlich auch Destruktor und überschriebene Zuweisung! : Klassen : Klassen Unterschied zwischen Kopierkonstruktor und Zuweisung Kopierkonstruktor: Initialisierung einer neu deklarierten Variable von existierender Variable Zuweisung: wirkt zwar wie Kopierkonstruktor (flache Kopie bzw. tiefe Kopie), überschreibt jedoch Speicher der existierenden Variable mit dem Speicher der zuweisenden, existierenden Variable zusätzlich ggf. Aufräumen: Freigabe dynamischer Speicher! außerdem: Rückgabe einer Referenz auf sich selbst Überladen von Operatoren CZeit& CZeit::operator+= (const CZeit& azeit) { mstd += azeit.mstd; mmin += azeit.mmin; msek += azeit.msek; normalize(); return *this; CZeit CZeit::operator+ (const CZeit& azeit) { CZeit z(*this); z += azeit; // Normalisierung via += return z; Addition mit Zuweisung Addition

11 : Klassen : Klassen Test int main() { Fortsetzung CZeit x(0,0,86399); // 23:59:59 x.anzeigen(); x.addsek(1); // 00:00:00 x.anzeigen(); x.addstd(12).addmin(13).addsek(14).anzeigen(); // 12:13:14 CZeit z1 = CZeit::Jetzt(); // statische Elementfunktion CZeit z2 = z1; // Zuweisung, nutzt aber Kopierkonstruktor! z1.anzeigen(); if (z1 == z2) // Operator == überladen cout << "Gleich!" << endl; CZeit a(1), b(0,1), c(0,0,1); // Nutzung der Defaults z1 += a; // Operator += überladen z1.anzeigen(); Fortsetzung auf nächster Folie 41 CZeit s; // Konstruktor für 00:00:00 s.anzeigen(); s += a + b + c; // Operatoren += und + überladen s.anzeigen(); CZeit t; t = a + b + c; // Operatoren = und + überladen; // Zuweisung nutzt überladenes = t.anzeigen(); 42 : Klassen 43 11