Informationsverarbeitung im Bauwesen

Transkript

1 Einleitung 1/25 Informationsverarbeitung im Bauwesen Einführung in das Programmieren mit C++ Markus Uhlmann Institut für Hydromechanik Karlsruher Institut für Technologie WS 2010/2011 Vorlesung 12

2 Einleitung 2/ VORLESUNG Überladen von Operatoren Advice: Define operators primarily to mimic conventional usage. B. Stroustrup

3 Einleitung 3/25 Fragen, die in dieser Vorlesung diskutiert werden Wie können Operationen zwischen Objekten durch natürliche Operatorsymbole ausgedrückt werden? Welche Möglichkeiten und Beschränkungen bestehen dabei?

4 Wieso Einleitung Überladen von Operatoren? Beispiel: Arbeiten mit Vektoren Addition von Vektoren: Addieren jedes Elementes int ort[3], verschiebung[3], resultat[3]; for (int i=0; i<3; i++) resultat[i]=ort[i]+verschiebung[i];//addition per Element implementiert durch eine Klasse vektor : vektor ort, verschiebung, resultat; resultat=ort.add(verschiebung); //Addition von Objekten wäre Folgendes nicht praktisch? resultat=ort+verschiebung; //Addition von Objekten Operator + überladen durch Additionsfunktion für Klasse vektor 4/25

5 Einleitung 5/25 Überladen von Operatoren: wie funktioniert es? resultat = ort + verschiebung; //Addition von Objekten typische Notation für Addition verbirgt den Mechanismus (Details), betont das Essentielle Syntax für Operatorfunktionen: <rueckgabetyp> operator <op> (<parameterliste>) Compiler ersetzt durch resultat=ort+verschiebung; resultat=ort.operator+(verschiebung); <op> beinhaltet i.d.r. Sonderzeichen (hier erlaubt)

6 Einleitung Operator + Beschränkungen Operatoren -, * Einführung in überladene Operatoren an einem Beispiel Eine Klasse zur Behandlung von Zeitdaten Zeitangabe bestehend aus Stunden, Minuten Wertebereich der Minuten: [0, 59] 2 Ganzzahlen Funktionen: Anzeigen, Summieren, Initialisieren, class Time{ 13 private: Version: ohne überladene Ops. 14 int hours; 15 int minutes; 26 int main(){ 16 public: 27 Time vorbereitung(1,30); 17 Time(); 28 Time implementierung(1,10); 18 Time(int h, int m=0); 19 void AddMin(int m); void AddHr(int h); gesamt=vorbereitung.sum(implementierung); void Reset(int h=0, int m=0); gesamt=gesamt.sum(fehlersuche); 22 Time Sum(const Time t) const; 23 void Show() const; (Quelltext 12.1) 6/25

7 Einleitung Operator + Beschränkungen Operatoren -, * Version mit überladenem Additionsoperator Ersetzen der Funktion Sum durch Operator + ermöglicht Operator- oder Funktionsschreibweise 11 class Time{ 12 private: 13 int hours; 14 int minutes; 15 public: 16 Time(); 17 Time(int h, int m=0); 18 void AddMin(int m); 19 void AddHr(int h); 20 void Reset(int h=0, int m=0); 21 Time operator+(const Time t) 22 const; 23 void Show() const; 24 }; Version: mit überladenem + 27 Time vorbereitung(1,30); 28 Time implementierung(1,10); 29 Time fehlersuche(0,40); 30 Time gesamt; 43 gesamt=vorbereitung+implementierung; 44 gesamt=gesamt+fehlersuche; 45 /* funktioniert auch: 46 gesamt=gesamt.operator+(fehlersuche); 47 */ (Quelltext 12.2) 7/25

8 Einleitung Operator + Beschränkungen Operatoren -, * 8/25 Regeln des Überladens von Operatoren (i) Regel 1: nur existierende Operatorsymbole verwenden es ist nicht möglich neue Operatorsymbole zu definieren Bsp: Operator ** zur Potenzierung (nicht möglich) Regel 2: manche Operatoren können nicht überladen werden Operatorsymbole, die nicht zu überladen sind: sizeof,., ::,? (und weitere) die meisten Operatorsymbole sind überladbar (sh. Tabelle)

9 9/25 Regeln des Einleitung Operator + Beschränkungen Operatoren -, * Überladens von Operatoren (ii) Regel 3: mind. ein Operand muss benutzerdefiniert sein Überladen von Operatoren soll neuen Datentypen dienen soll verhindern, Standardoperationen neu zu definieren Bsp: Redefinition von - für zwei Ganzzahlen nicht möglich Regel 4: Eigenschaften des Operators bleiben unverändert Überladen kann nicht die Priorität des Operators ändern ebenso bleibt Anzahl der Operanden erhalten Bsp: int x=5; Time training; % x; //illegal fuer Restwertoperator % training; //illegal fuer ueberladenen Op.

10 Einleitung Operator + Beschränkungen Operatoren -, * 10/25 Regeln des Überladens von Operatoren (iii) Regel 5: einige Operatoren müssen Elementfunktionen sein die meisten Operatoren können entweder als Elementfunktionen oder nicht-elementfunktionen implementiert werden Ausnahmen sind: =, (), [], -> nur als Elementfunktionen zu redefinieren Empfehlung: Überladen sinnverwandt mit Originaloperator Operatorsymbol soll Sinn der Operation suggerieren bei Nichtbeachtung: unverständlicher Code Bsp: Überladen von * durch Vektoraddition (nein!)

11 Einleitung Operator + Beschränkungen Operatoren -, * 11/25 Zeitklasse mit weiteren Operatoren (Version 1) Funktion für Subtraktion zweier Zeitspannen: - Multiplikation einer Zeitspanne mit Faktor: * 11 class Time{ 12 private: 13 int hours; 14 int minutes; 15 public: 16 Time(); 17 Time(int h, int m=0); 18 Time operator+(const Time t) 19 const; 20 Time operator-(const Time t) 21 const; 22 Time operator*(const float mult) 23 const; 24 void Show() const; Version: mit +, -, * 27 int main(){ 28 Time planen(18,30); 29 Time herstellen(60,0); 30 Time gesamt,diff,korrigiert; 42 gesamt=planen+herstellen; 43 diff=herstellen-planen; 44 korrigiert=gesamt*1.25; (Quelltext 12.3)

12 Einleitung Operator + Beschränkungen Operatoren -, * 12/25 Zeitklasse mit weiteren Operatoren: Problem Multiplikationsoperator erlaubt keine Vertauschung Multiplikation gesamt*1.25 möglich (s.o.) mathematisch äquivalentes 1.25*gesamt nicht möglich! wieso nicht? Elementfunktion: erster Operand ist aufrufendes Objekt aber hier 1.25 kein Objekt! Lösung: Implementierung des Operators als nicht-elementfunktion Funktion benötigt folgende Signatur (Prototyp): Time operator*(double mult, Time t) Funktion benötigt Zugriffsrechte auf Elementvariablen Deklaration als friend in Klasse Time

13 Einleitung Operator + Beschränkungen Operatoren -, * 13/25 Zeitklasse mit weiteren Operatoren (Version 2) nicht-elementfunktion wird Teil der Schnittstelle der Klasse 12 class Time{ 13 private: 14 int hours; 15 int minutes; 16 public: 17 Time operator+(const Time t) 18 const; 19 Time operator-(const Time t) 20 const; 21 Time operator*(const float mult) 22 const; 23 friend Time operator*( 24 const float mult, 25 const Time t); Version: mit friend 31 int main(){ 32 Time planen(18,30); 33 Time herstellen(60,0); 34 Time gesamt,diff,korrigiert; 46 //Elementfunktion: 47 korrigiert=gesamt*1.25; 48 //nicht-elementfunktion: 49 korrigiert=1.25*gesamt; (Quelltext 12.4)

14 Einleitung Operator + Beschränkungen Operatoren -, * Zeitklasse mit weiteren Operatoren (Version 3) friend Status kann vermieden werden: nicht-elementfunktion kehrt lediglich Reihenfolge um aber: Funktion taucht nicht in Deklaration von Time auf 12 class Time{ 13 private: 14 int hours; 15 int minutes; 16 public: 17 Time operator+(const Time t) 18 const; 19 Time operator-(const Time t) 20 const; 21 Time operator*(const float mult) 22 const; 23 //keine friend Deklaration 24 void Show() const; 25 Time(); Version: ohne friend 105 Time operator*( 106 const float mult, 107 const Time t){ 108 //ruft nur oeffentliche 109 // Elementfunktion mit 110 // umgekehrter Reihenfolge 111 // auf 112 //-> benoetigt keinen 113 // friend Status 114 return t*mult; 115 }; (Quelltext 12.5) 14/25

15 Einleitung Operator + Beschränkungen Operatoren -, * 15/25 Bemerkungen zu nicht-elementfunktionen nicht-elementfunktionen, welche die Funktionalität einer Klasse erweitern Hilfsfunktionen Hilfsfunktionen sollten zusammen mit eigentlicher Klasse deklariert und definiert werden Quelltext in gleicher Datei wie Klasse anordnen Elementfunktion oder nicht-elementfunktion? manche Operatoren erlauben nur Elementfunktion (s.o.) sonst: beide Optionen meist äquivalent

16 16/25 Einleitung Operator << Beispiel: komplexe Zahlen Überladen des Operators << zur Ausgabe von Time Bildschirmausgabe durch Objekt cout (Typ ostream) Operator << ist bereits überladen für diverse Basistypen wir wünschen uns Folgendes für die Klasse Time: Time film; cout << film; //gibt Laenge des Films aus Implementierung als nicht-elementfunktion (denn: cout<<film ist sonst äquivalent zu cout.operator<<(film) )

17 17/25 Einleitung Operator << Beispiel: komplexe Zahlen Operator << für die Klasse Time (Version 1) analog zu Operator * in Programm 12.4 Problem: diese Version erlaubt keine Verkettung 19 class Time{ 20 private: 21 int hours; 22 int minutes; 23 public: 24 Time(); 25 Time(int h, int m=0); 26 friend void operator<<( 27 ostream & os, 28 const Time & t); 29 }; Version: void 31 int main(){ 32 Time halbzeit1(0,45); 33 cout << "Halbzeit1: "; 34 cout << halbzeit1; 54 void operator<<(ostream & os, 55 const Time & t) { 56 os << t.hours << " Stunden, " 57 << t.minutes << " Minuten"; 58 } (Quelltext 12.6)

18 18/25 Einleitung Operator << Beispiel: komplexe Zahlen Operator << für die Klasse Time (Version 2) Verkettung von Ausgabeoperationen: cout<<zeit1<<zeit2 jede einzelne Operation muss Objekttyp ostream liefern 14 class Time{ 15 private: 16 int hours; 17 int minutes; 18 public: 19 Time(); 20 Time(int h, int m=0); 21 friend ostream & operator<<( 22 ostream & os, 23 const Time & t); 24 }; Version: ostream & 31 /* Verkettung funktioniert: */ 32 cout << "Halbzeit1: " 33 << halbzeit1 34 << "; " 35 << "Halbzeit2: " 36 << halbzeit2 37 << "; " 38 << "Nachspiel: " 39 << nachspiel 40 << endl; (Quelltext 12.7)

19 19/25 Einleitung Beispiel: Klasse für komplexe Zahlen Operator << Beispiel: komplexe Zahlen Komplexe Zahlen komplexe Zahlen besitzen Real- und Imaginärteil c = c r + I c i mit: I = 1 und reellen c r, c i Konsequenzen für arithmetische Operationen Überladen von Operatoren bietet sich an es existiert eine Klasse complex in Standardbibliothek dieser Entwurf dient nur zu Übungszwecken

20 20/25 Einleitung Klasse complex Operator << Beispiel: komplexe Zahlen Deklaration 15 class complex{ 16 private: 17 //Elementdaten 18 double re; //Realteil 19 double im; //Imaginaerteil 20 //-> c=c.re+c.im*i 21 //[ I steht fuer wurzel(-1)] 22 public: 23 //Konstruktor: 24 complex(double r=0, double i=0) : 25 re(r), im(i) { } //Zugriffsfunktionen: 28 double real() const {return re;} 29 double imag() const {return im;} //Zusammengesetzte binaere Operatoren: 32 complex & operator+=(complex c); 33 complex & operator+=(double d); 34 complex & operator*=(complex c); 35 complex & operator*=(double d); 36 //fehlen: -=, /= 37 }; (Quelltext 12.8)

21 Einleitung Klasse complex (ii) Operator << Beispiel: komplexe Zahlen Implementierung 39 complex & complex::operator+=(complex c){ 40 re += c.re; 41 im += c.im; 42 return *this; // this pointer zeigt auf das 43 //Objekt selber 44 } 45 complex & complex::operator+=(double d){ 46 re += d; 47 return *this; 48 } 49 complex & complex::operator*=(complex c){ 50 //Vorschrift zur Multiplikation 51 // zweier komplexer Zahlen: 52 //a*b=(ar+i*ai)*(br+i*bi) 53 // =(ar*br-ai*bi)+i*(ai*br+bi*ar) 54 double r = re*c.real()-im*c.imag(); 55 double i = im*c.imag()+re*c.real(); 56 re = r; 57 im = i; 58 return *this; // this pointer zeigt auf das 59 //Objekt selber 60 } 61 complex & complex::operator*=(double d){ 62 re *= d; 63 im *= d; 64 return *this; 65 } 21/25

22 22/25 Einleitung Klasse complex (iii) Operator << Beispiel: komplexe Zahlen Hilfsfunktionen 68 //1. binaere Operatoren 69 complex operator+(complex a, complex b){ 70 complex r = a; 71 return r += b;//aufruf: complex::operator+=(complex) 72 } 73 complex operator+(complex a, double b){ 74 complex r = a; 75 return r += b;//aufruf: complex::operator+=(double) 76 } 77 complex operator+(double a, complex b){ 78 complex r = b; 79 return r += a;//aufruf: complex::operator+=(double) 80 } 81 complex operator*(complex a, complex b){ 82 complex r = a; 83 return r *= b;//aufruf: complex::operator*=(complex) 84 } 85 complex operator*(complex a, double b){ 86 complex r = a; 87 return r *= b;//aufruf: complex::operator*=(double) 88 } 89 complex operator*(double a, complex b){ 90 complex r = b; 91 return r *= a;//aufruf: complex::operator*=(double) 92 } 93 //fehlen: -, /

23 Einleitung Klasse complex (iv) Operator << Beispiel: komplexe Zahlen Hilfsfunktionen 2 95 //2. unaere Operatoren 96 complex operator+(complex a){ 97 return a; 98 } 99 /* complex operator-(complex a){ 100 return a*(double(-1));//aufruf: complex::operator*=(double) 101 } */ 102 //3. Vergleichsoperatoren 103 bool operator==(complex a, complex b){ 104 return a.real() == b.real() && 105 a.imag() == b.imag() ; 106 } 107 //fehlt:!= //4. Ein/Ausgabeoperatoren 110 ostream & operator<<(ostream & os, complex c){ 111 os << c.real() << "+I*(" << c.imag() <<")"; 112 return os; 113 } 114 //fehlt: >> //5. diverse mathematische Funktionen 117 complex conj(complex c){ 118 //konjugiert komplexe Zahl 119 complex r=complex(c.real(),c.imag()*(-1)); 120 return r; 121 } 23/25

24 24/25 Einleitung Klasse complex (v) Operator << Beispiel: komplexe Zahlen Testprogramm 138 int main(){ 139 //einige moegliche Operationen mit Typ complex 140 complex a = complex(1,2); 141 cout << "a = " << a << endl; complex b = 3; 144 cout << "b = " << b << endl; complex c = a+2.3; 147 cout << "c = a+2.3 = " << c << endl; complex d = 2+b; 150 cout << "d = 2+b = " << d << endl; complex e = a*c; 153 cout << "e = a*c = " << e << endl; return 0; 156 }

25 25/25 Einleitung Klasse complex freiwillige Aufgabe Operator << Beispiel: komplexe Zahlen komplettieren Sie das Programm (12.8), indem Sie die fehlenden Operatorfunktionen und Hilfsfunktionen ergänzen

26 1/5 Zusammenfassung Anhang Zusammenfassung Literatur Mehr Überladen von Operatoren erlaubt intuitiven Syntax bei Operationen zwischen Objekten sollte wohldosiert eingesetzt werden Elementfunktion: erster Operand ist aufrufendes Objekt falls dies nicht erwünscht: nicht-elementfunktion überladene Operatoren behalten ihre Eigenschaften bei: Anzahl der Operanden, Priorität, Assoziativität

27 2/5 Anhang Anhang Zusammenfassung Literatur Mehr

28 3/5 Anhang Zusammenfassung Literatur Mehr Weiterführende Literatur S. Prata, C++ Primer Plus, Sams, 2005 S. Oalline, Practical C++ Programming, O Reilly, 2003 J. Liberty and B. Jones, Teach yourself C++ in 21 days, Sams, 2005 R. Lischner, C++ in a Nutshell, O Reilly, 2003 Handbücher erhältlich am Rechenzentrum: (Weblink) RRZN, Die Programmiersprache C, 17. Auflage, 2008 RRZN, C++ für C Programmierer, 13. Auflage, 2005 Online Dokumentation zum C++ Standard (Weblink) (freie) Microsoft Software für Studenten am KIT: (Weblink)

29 Bedingungsoperator? Anhang Zusammenfassung Literatur Mehr Der einzige ternäre Operator (mit 3 Operanden) in C++ Syntax: <bedingung>? <Anweisung1> : <Anweisung2> falls <bedingung> wahr: führt <Anweisung1> aus, sonst: führt <Anweisung2> aus Abkürzung für äquivalentes if...else int main (){//Bsp: Operator? int a=2,b=7,c; c = (a>b)? a : b; cout << c; return 0;} int main (){//Bsp: if...else int a=2,b=7,c; if (a>b) c=a; else c=b; cout << c; return 0;} 4/5

30 5/5 Anhang Zusammenfassung Literatur Mehr Operatorsymbole, die überladen werden können + - * / % ^ & ~=! = < > += -= *= /= %= ^= &= = << >> >>= <<= ==!= <= >= && ++ --, ->* -> () [] new delete new [] delete []