C++ Programmierkurs. Wintersemester 04 / 05. Christian Hagemeier. Lehrstuhl Prof. Dr. Schrader Institut für Informatik Universität zu Köln

Transkript

1 C++ Programmierkurs 1 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 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 2

2 3 5. 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 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) 4

3 5 Wiederholung: Implementation von Klassen Schlüsselwort class Aufbau üblicherweise: class name { public: Methodendeklaration private: Attribute }; 5.6 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 6

4 7 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 Auszug: konstante Methoden (1) 8 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 54 // return hour value 55 int Time::getHour() const 56 { 57 return hour; 59 } // end function gethour const Funktionen modifizieren nicht das Objekt.

5 9 Auszug: konstante Methoden (2) 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 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) {... } 10

6 friend-elemente 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. 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

7 Beispiel: friend (1) 13 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; 7 8 // Count class definition 9 class Count { Funktionsprototyp wird mit Schlüsselwort friend. 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 21 Beispiel: friend (2) // output x 23 void print() const 24 { 25 cout << x << endl; } // end function print private: 30 int x; // data member }; // end class Count // 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 } // end function setx 41 Count Objekt muß normal für Funktion übergeben werden, da keine Methode. Da setx friend von Count ist, kann es auf private Variable x zugreifen und sie modifizieren.

8 15 Beispiel: friend (3) 42 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(); return 0; } // end main Hier wird friend Funktion für Zugriff und Modifikation von x verwendet. counter.x after instantiation: 0 counter.x after call to setx friend function: Dynamische Speicherverwaltung 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> 16

9 17 Operatoren new und delete 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 5.9 Statische Klassenelemente 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 18

10 19 Zugriff auf statische Variablen 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() Statische Methoden 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) 20 Statische Methoden und Variablen existieren unabhängig von Objekten der Klasse!

11 Überladen von Operatoren Grundlagen Methoden vs. friend-funktionen Details zum Überladen von Operatoren Überladen von stream-operatoren 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

12 23 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 += Ausnahmen 24 Operators that can be overloaded + - * / % ^ & ~! = < > += -= *= /= %= ^= &= = << >> >>= <<= ==!= <= >= && >*, -> [] () new delete new[] delete[] Operators that cannot be overloaded..* ::?: sizeof

13 25 Methoden vs. friend-funktionen 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 Beispiel Methode vs. Funktion Beispiel Klassenmethode: class Test { public: Test operator+( const Test &t ) const; private: int data; }; 26 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; }

14 27 Beispiel: Überladen von << und >> (1) 1 // Fig. 8.3: fig08_03.cpp 2 // Overloading the stream-insertion and 3 // stream-extraction operators. 4 #include <iostream> 12 #include <iomanip> 13 #include <string> 14 using namespace std; // PhoneNumber class definition 17 class PhoneNumber { Prototypen für überladene Operatoren >> und << können keine Methoden sein, da linker Operand nicht von Klasse Phonenumber ist: 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: Überladen von << und >> (2) // 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 ) >> num.areacode; // input area code 47 input.ignore( 2 ); // skip ) and space 48 input >> setw( 4 ) >> num.exchange; // input 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>>

15 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 Eingabebuchstaben (1 als // 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 ) >> num.areacode; // input area code 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; // input line lesenden Buchstaben. 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)