C++ Programmierkurs. 5. Klassen. Wintersemester 04 / 05. Christian Hagemeier Lehrstuhl Prof. Dr. Schrader

Transkript

1 C++ Programmierkurs Wintersemester 04 / 05 Christian Hagemeier Lehrstuhl Prof. Dr. Schrader Institut für Informatik Universität zu Köln mittwochs 17 18:30 Uhr Hörsaal II der Physikalischen Institute Klassen 5.1 Einführung in Objektorientierung 5.2 Implementation von Klassen 5.3 Zugriffssteuerung in Klassen 5.4 Konstruktoren und Destruktoren 5.5 Objektorientiertes Softwaredesign 5.6 Konstante Klassenelemente 5.7 friend-elemente 5.8 Dynamische Speicherverwaltung: new, delete 5.9 Statische Klassenelemente 5.10 Überladen von Operatoren Gliederung der Vorlesung : Organisatorisches und Einführung : Einführung und Kontrollstrukturen : Kontrollstrukturen : Kontrollstrukturen und Funktionen : Funktionen : Vektoren, Zeiger : Zeiger, Strings : Klassen (1) : Klassen (2), Überladen von Operatoren : Vererbung und Polymorphismus : Datei und Stream Ein /Ausgabe Wiederholung: Objektorientierung Zentraler Aspekt: Kapselung von Daten (Eigenschaften) Funktionen (Verhalten) in Klassen Klassen können als Vorlagen betrachtet werden: es können beliebig viele konkrete Instanzen davon erzeugt werden Prinzip des Information Hiding es wird definiert, wie Klassen miteinander kommunizieren (Interfaces) es wird versteckt, wie die jeweilige Aufgabe erledigt wird Aktionsorientierung (strukturierte Programmierung) vs. Objektorientierung (OO Programmierung)

2 5 7 Wiederholung: Implementation von Klassen Schlüsselwort class Aufbau üblicherweise: class name { public: Methodendeklaration private: Attribute ; Konstante Methoden Bisher: Schlüsselwort const nur für (eingebaute) Variablen Ist Instanz einer Klasse konstant, so dürfen nur konstante Funktionen verwendet werden! Schlüsselwort const muß sowohl in Prototyp als auch Definition der Funktion angegeben werden: Prototyp: nach Parameterliste Definition: vor öffnender geschweifter Klammer Konstruktoren und Destruktor können nicht konstant sein Konstruktor muß in der Lage sein Objekt zu initialisieren Destruktor muß Aktionen zur Beendigung durchführen können Konstante Klassenelemente Prinzip der geringsten Legitimierung: Erlaube nur notwendige Modifikationen an Objekten Schlüsselwort const spezifiziert Objekt, das nicht modifiziert werden soll Syntaxfehler, falls konstantes Objekt modifiziert wird Beispiel: const Time mittag (12, 0, 0); definiert konstantes Objekt mittag der Klasse Time wird mir 12 initialisiert Auszug: konstante Methoden (1) 7 class Time { 8 9 public: 10 Time( int = 0, int = 0, int = 0 ); // default constructor 18 // get functions (normally declared const) 19 int gethour() const; // return hour 32 // end class Time ; const Funktionen modifizieren 54 nicht das Objekt. // return hour value 55 int Time::getHour() const 56 { 57 return hour; 59 // end function gethour

3 Auszug: konstante Methoden (2) friend-elemente 11 8 int main() 9 { 10 Time wakeup( 6, 45, 0 ); // non-constant object 11 const Time noon( 12, 0, 0 ); // constant object // OBJECT MEMBER FUNCTION 14 wakeup.sethour( 18 ); // non-const non-const noon.sethour( 12 ); // const non-const wakeup.gethour(); // non-const const 19 Versuch der Ausführung einer 20 noon.getminute(); // const const nicht konstanten Methode auf 21 noon.printuniversal(); // const const konstantem Objekt ist Syntaxfehler noon.printstandard(); // const non-const return 0; // end main werden außerhalb der Klasse definiert haben das Recht nicht-öffentliche Elemente der Klasse zu verwenden Deklaration: bei Funktionen: Schlüsselwort friend vor Prototyp schreiben Alle Funktionen von KlasseZwei sollen friend von KlasseEins sein: Deklaration der Form friend class KlasseZwei in die Definition von KlasseEins. Variableninitialisierung in Klassen Spezielle Initialisierung bei Konstruktoren kann für alle Variablen einer Klasse verwendet werden muß für konstante Variablen eingesetzt werden Liste der Initialisierungen nach Doppelpunkt hinter Argumentliste: Date::Date( int h, int m, int s ) : hour (h), minute (m), second (s) { Eigenschaften von friend Freundschaft wird zugewiesen (also von der Klasse, auf die zugegriffen werden soll), nicht genommen KlasseZwei Freund von KlasseEins: KlasseEins muß Freundschaft explizit deklarieren Nicht symmetrisch: KlasseZwei ist Freund von KlasseEins KlasseEins ist dann aber nicht automatisch Freund von KlasseZwei Nicht transitiv: KlasseZwei ist friend von KlasseEins KlasseDrei ist friend von KlasseZwei Dann ist KlasseDrei nicht automatisch friend von KlasseEins 12

4 Beispiel: friend (1) 13 Beispiel: friend (3) 15 1 // Fig. 7.11: fig07_11.cpp 2 // Friends can access private members of a class. 3 #include <iostream> 4 5 using std::cout; 6 using std::endl; Funktionsprototyp wird mit 7 Schlüsselwort friend. 8 // Count class definition 9 class Count { Gestartet. 10 friend void setx( Count &, int ); // friend declaration public: // constructor 15 Count() 16 : x( 0 ) // initialize x to 0 17 { 18 // empty body // end Count constructor int main() 43 { 44 Count counter; // create Count object cout << "counter.x after instantiation: "; 47 counter.print(); setx( counter, 8 ); // set x with a friend cout << "counter.x after call to setx friend function: "; 52 counter.print(); Hier wird friend Funktion return 0; für Zugriff und Modifikation 55 von x verwendet. 56 // end main counter.x after instantiation: 0 counter.x after call to setx friend function: 8 Beispiel: friend (2) Dynamische Speicherverwaltung // output x 23 void print() const 24 { 25 cout << x << endl; // end function print private: 30 int x; // data member Count Objekt muß normal 31 für Funktion übergeben 32 ; // end class Count werden, da keine Methode // function setx can modify private data of Count 35 // because setx is declared as a friend of Count 36 void setx( Count &c, int val ) 37 { 38 c.x = val; // legal: setx is a friend of Count 39 Da setx friend von 40 // end function setx 41 Count ist, kann es auf private Variable x zugreifen und sie modifizieren. Bisher: Speicherbeschaffung automatisch durch Compiler bei Initialisierung von Variablen Jetzt: explizite Anforderung neuen Speichers kontrolliert Beschaffung und Freigabe von Speicher mittels Operatoren new und delete Headerdatei <new>

5 Operatoren new und delete 17 Zugriff auf statische Variablen 19 new Beispiel: Time *timeptr; timeptr = new Time; Operator new Erzeugt Objekt von entsprechender Größe des Typs Time ruft Defaultkonstruktor des Objekts auf liefert Zeiger auf entsprechenden Speicher zurück Initialisierung möglich: double *ptr = new double( ); Time *timeptr = new Time( 12, 0, 0 ); delete zerstört dynamisch erzeugtes Objekt und gib Speicher frei ruft Destruktor auf ansprechbar über beliebige Instanz public static Variablen können auch direkt mittels Bereichsauflösungsoperator angesprochen werden: Employee::count private static Variablen (falls keine Instanz existiert): kann nur über public static Methode angesprochen werden zum Aufruf dieser Funktion: Bereichsauflösungsoperator: Employee::getCount() 5.9 Statische Klassenelemente 18 Statische Methoden 20 spiegelt klassenweite Daten wieder Eigenschaft der Klasse, die sich nicht an einem bestimmten Objekt festmachen läßt erscheinen zuerst wie globale Variablen, besitzen aber nach wie vor Klassengeltungsbereich (sind also nur aus der Klasse heraus ansprechbar) werden genau einmal initialisiert: bei Abarbeitung der entsprechenden Stelle der Datei durch Compiler existiert, auch wenn kein Objekt der Klasse existiert Kann selbst wieder public, private (oder protected) sein auch Methoden können statisch sein Sollen Methoden auch unabhängig von Instanzen (Objekten) der Klasse aufrufbar sein, so müssen diese statisch sein: Schlüsselwort static vor Methodendeklaration statische Methoden dürfen keine nicht-statischen Variablen der Klasse verwenden (da diese zum Ausführungszeitpunkt nicht existieren müssen) Statische Methoden und Variablen existieren unabhängig von Objekten der Klasse!

6 5.10 Überladen von Operatoren Grundlagen Methoden vs. friend-funktionen Details zum Überladen von Operatoren Überladen von stream-operatoren 21 Details Nicht geändert werden kann: Funktionsweise bei eingebauten Datentypen Auswertungsreihenfolge der Operatoren Evtl. Verwendung von Klammern Assoziativität (links-rechts oder rechts-links) Anzahl der Operanden Neue Operatoren können nicht definiert werden! Alle Operatoren müssen explizit überladen werden: Überladen von + erzeugt keinen entsprechenden Operator += 23 Grundlagen zum Überladen von Operatoren Warum Operatoren? Intuitiver zu lesen: a + b besser als a.add(b) Kontextsensitivität << ist entweder Ausgabeoperator oder Leftshift-Operator Es können existierende Operatoren für eigene Klassen genutzt werden Neue Operatoren können nicht definiert werden Überladen von Operatoren funktioniert genauso wie Überladen "normaler" Funktionen: entsprechender Funktionsname: "operator" plus entsprechendes Zeichen Beispiel: operator+(... ) 22 Ausnahmen Operators that can be overloaded + - * / % ^ & ~! = < > += -= *= /= %= ^= &= = << >> >>= <<= ==!= <= >= && >*, -> [] () new delete new[] delete[] Operators that cannot be overloaded..* ::?: sizeof 24

7 Methoden vs. friend-funktionen 25 Beispiel: Überladen von << und >> (1) 27 Operator als Methode der entsprechenden Klasse erster (oder einziger) Operand ist automatisch aktuelle Instanz der Klasse Operator als friend-funktion Operator kann als "normale" Funktion definiert werden dann müssen alle Operatoren explizit als Argumente in Argumentliste übergeben werden Bei Zugriff auf private/protected Klassenvariablen: Operator-Funktion muß friend sein Operatoren werden ausgeführt, wenn entsprechende Operation mit den definierten Argumenttypen verwendet wird 1 // Fig. 8.3: fig08_03.cpp 2 // Overloading the stream-insertion and 3 // stream-extraction operators. Prototypen für überladene Operatoren 4 #include <iostream> >> und << können keine Methoden 12 #include <iomanip> sein, da linker Operand nicht von 13 #include <string> Klasse Phonenumber ist: 14 using namespace std; // PhoneNumber class definition 17 class PhoneNumber { cin << object cout >> object 18 friend ostream &operator<<( ostream&, const PhoneNumber & ); 19 friend istream &operator>>( istream&, PhoneNumber & ); private: 22 string areacode; // 3-digit area code 23 string exchange; // 3-digit exchange 24 string line; // 4-digit line // end class PhoneNumber ; Beispiel Methode vs. Funktion 26 Beispiel: Überladen von << und >> (2) 28 Beispiel Klassenmethode: class Test { public: Test operator+( const Test &t ) const; private: int data; ; Test operator+( const Test &t ) const { return data + t.data; Beispiel Funktion: Test operator+( const Test &t1, const Test &t2) const { return t1.data + t2.data; 28 // overloaded stream-insertion operator; cannot be 29 // a member function if we would like to invoke it with 30 // cout << somephonenumber; 31 ostream &operator<<( ostream &output, const PhoneNumber &num ) 32 { 33 output << "(" << num.areacode << ") " 34 << num.exchange << "-" << num.line; return output; // enables cout << a << b << c; // end function operator<< // overloaded stream-extraction operator; 43 istream &operator>>( istream &input, PhoneNumber &num ) 44 { 45 input.ignore(); // skip ( 46 input >> setw( 4 // input area ) >> num.areacode; code 47 input.ignore( 2 ); // skip ) and space 48 input >> setw( 4 ) // input exchange >> num.exchange; 49 input.ignore(); // skip dash (-) 50 input >> setw( 5 ) >> num.line; // input line 52 return input; // enables cin >> a >> b >> c; 54 // end function operator>>

8 Beispiel: Überladen von << und >> (2) // overloaded stream-insertion operator; cannot Der be Ausdruck 29 // a member function if we would like to invoke it with cout << phone; 30 // cout << somephonenumber; wird als folgender Funktionsaufruf 31 ostream &operator<<( ostream &output, const PhoneNumber &num ) interpretiert: 32 { 33 output << "(" << num.areacode << ") " operator<<(cout, phone); 34 << num.exchange << "-" << num.line; output ist ein Alias für cout return output; // enables cout << a << b << c; 37 ignore() überspringt 38 // angegebene end function Anzahl operator<< an 39 Eingabebuchstaben (1 als 40 // Defaultwert). overloaded stream-extraction operator; Hierdurch können Objekte bei Ausgabe 43 istream &operator>>( istream &input, PhoneNumber &num ) "geschachtelt" werden: 44 { cout << phone1 << phone2; 45 input.ignore(); // skip ( ruft als erstes 46 input >> setw( 4 // input area code ) >> num.areacode; 47 input.ignore( 2 ); // skip operator<<(cout, ) and space phone1) auf und 48 input >> setw( 4 ) >> num.exchange; // input liefert exchange cout zurück. Stream Manipulator setw 49 input.ignore(); // skip Dann dash wird (-) cout << phone2 ausgeführt. beschränkt die Anzahl der zu 50 input >> setw( 5 ) >> num.line; lesenden Buchstaben. // input line 52 return input; // enables cin >> a >> b >> c; setw(4) erlaubt das 54 // end function operator>> Einlesen von 3 Zeichen. Beispiel: Überladen von << und >> (3) int main() 57 { 58 PhoneNumber phone; // create object phone cout << "Enter phone number in the form (123) :\n"; // cin >> phone invokes operator>> by implicitly issuing 63 // the non-member function call operator>>( cin, phone ) 64 cin >> phone; cout << "The phone number entered was: " ; // cout << phone invokes operator<< by implicitly issuing 69 // the non-member function call operator<<( cout, phone ) 70 cout << phone << endl; return 0; 74 // end main Enter phone number in the form (123) : (800) The phone number entered was: (800)