C++ Teil 4. Sven Groß. 30. Apr IGPM, RWTH Aachen. Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 16

Transkript

1 C++ Teil 4 Sven Groß IGPM, RWTH Aachen 30. Apr 2015 Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 16

2 Themen der letzten Vorlesung Funktionen: Definition und Aufruf Wert- und Referenzparameter, call by value / call by reference Lesbarkeit von Code: Einrückung, Kommentare Namensräume Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 16

3 Heutige Themen 1 Hands-on Live Programming zu A2 2 Gleitkommazahlen Rundungsfehler Auswirkung auf Vergleiche 3 Funktionen Überladung Rekursion 4 Typumwandlung (Cast) Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 16

4 Binäre Zahlendarstellung char, int, unsigned int, long,... werden als Binärzahlen dargestellt. Beispiel: (11010) 2 = = = 26. double, float werden als binäre Gleitkommazahlen dargestellt: ˆx = ±0.d 1... d m 2 e M mit Binärziffern d j {0, 1}, Mantissenlänge m und Exponent e. M ist die Menge der Maschinenzahlen. Beispiel: (m = 6) ˆx = ( ) 2 2 (11)2 M = ( ) 2 3 = = Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 16

5 Gleitkommazahlen: Rundungsfehler viele x R nicht exakt darstellbar, z.b. x = 0.3 / M Rundung zu ˆx M double a= 0.3; // a ist nicht exakt 0.3 arithmetische Operationen mit Gleitkommazahlen (floating point operations, FLOPs): Assoziativ-, Distributivgesetz gelten nicht! Grund sind Rundungsfehler: nach Operation wird Ergebnis x R auf nächste darstellbare Gleitkommazahl ˆx M gerundet. relativer Fehler durch Rundung ˆx x x 1 =: eps 2m ˆx = x (1 + ε) mit ε eps. Maschinengenauigkeit eps: für double ist eps = , für float ist eps = (nicht mal TR-Genauigkeit) Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 16

6 Rundungsfehler: Auswirkung auf Vergleiche int main () { const double elftel = 1./11.; } for ( double x =0; x <= 1.0; x += elftel ) cout << " x = " << x << endl ; return 0; Schleife sollte (mathematisch) eigentlich von 0 also 12 Durchläufe, aber 11, Rundungsfehler nach jeder Addition durch += Rundungsfehler häufen sich an (akkumulieren),... bis = 1 zählen, im Rechner nicht exakt darstellbar Rundungsfehler je nach Prozessortyp / Compiler / Optimierungsstufe wird die Schleife 11 oder 12 mal durchlaufen: letzter Durchgang wird evtl. weggelassen, da dann x evtl. geringfügig größer als 1 ist Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 16

7 Sinnvolle Vergleiche mit double Bessere Alternativen? 1 Vergleich robust für Rundungsfehler machen: for ( double x =0; x <= e -8; x += elftel ) cout << " x = " << x << endl ; 2 Schleifenvariablen immer ganzzahlig wählen: Vorsicht bei == : for ( int i =0; i <= 11; ++ i) cout << " x = " << i* elftel << endl ; Vergleiche wie x == 0.1 testen Gleichheit der Binärdarstellung, wegen Rundungsfehlern sinnlos, bitte immer so: if ( std :: abs ( x - 0.1) <= 1e -9 ) {... } Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 16

8 Signatur einer Funktion Signatur einer Funktion = Name + Parameterliste Funktionen dürfen selben Namen besitzen, aber Signatur muss eindeutig sein. Drei verschiedene Funktionen mit verschiedener Signatur: void PrintSum ( int x, int y); void PrintSum ( double x, double y); void PrintSum ( double x, double y, double z); Nicht erlaubt, da beide Funktionen selbe Signatur besitzen: int Summe ( double x, double y); double Summe ( double a, double b); Eindeutige Signatur wichtig, damit der Compiler beim Funktionsaufruf die richtige Funktion auswählen kann, z.b. bei PrintSum( 1.0, 3.0); Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 16

9 Funktionsüberladung 1 void PrintSum ( int x, int y) 2 { 3 cout << "i- sum = " << x + y << endl ; 4 } 5 6 void PrintSum ( double x, double y) 7 { 8 cout << "d- sum = " << x + y << endl ; 9 } int main () 12 { 13 PrintSum ( 1, 3); // Ausgabe "i- sum = 4" 14 PrintSum ( 1.3, 2.7); // Ausgabe "d- sum = 4" 15 return 0; 16 } Überladen: Funktionen mit gleichem Namen und gleicher Parameterzahl, aber verschiedenen Typen unterscheidbar durch Signatur Eindeutige Signatur wichtig, damit richtige Funktion ausgewählt wird Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 16

10 Funktionsüberladung (2) 1 void PrintSum ( double x, double y) 2 { 3 cout << "d- sum = " << x + y << endl ; 4 } 5 6 int main () 7 { 8 PrintSum ( 1, 3); // Ausgabe "d- sum = 4" 9 PrintSum ( 1.3, 2.7); // Ausgabe "d- sum = 4" 10 return 0; 11 } PrintSum( 1, 3); bewirkt keinen Compilerfehler, obwohl keine int-funktion deklariert ist. Grund: automatische, implizite Typumwandlung (Cast) für int double oft nützlich, aber manchmal auch gefährlich. Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 16

11 Funktionsüberladung (3) 1 void PrintSum ( int x, int y) 2 { 3 cout << "i- sum = " << x + y << endl ; 4 } 5 6 int main () 7 { 8 PrintSum ( 1, 3); // Ausgabe "i- sum = 4" 9 PrintSum ( 1.3, 2.7); // Ausgabe "i- sum = 3" 10 return 0; 11 } PrintSum( 1.3, 2.7); bewirkt keinen Compilerfehler, obwohl keine double-funktion deklariert ist. Grund: automatische, implizite Typumwandlung (Cast) für double int Informationsverlust! Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 16

12 Funktionsüberladung warnendes Beispiel 1 # include < iostream > 2 using namespace std ; // gefaehrlich! 3 4 void max ( double a, double b) 5 { 6 double maxi = a >b? a : b; 7 cout << " Das Maximum ist " << maxi << endl ; 8 } 9 10 int main () 11 { 12 max ( 3, 4); // ruft std :: max fuer int auf 13 return 0; 14 } am besten passende Funktion wird aufgerufen, hier int std::max( int, int) Besser: using std::cout; using std::endl; statt using namespace std;, um Vorteil des Namensraums (Kapselung, Eindeutigkeit) zu erhalten Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 16

13 Rekursive Funktionen Rekursive Funktionen rufen sich selber auf sicherstellen, dass Rekursion abbricht! einfache Rekursion kann auch durch Iteration (Schleife) ersetzt werden int fakultaet_ rekursiv ( int n) { if (n >1) return n* fakultaet_ rekursiv (n -1); else return 1; // Abbruch der Rekursion } int fakultaet_ iterativ ( int n) { int fak = 1; for ( int i =1; i <=n; ++i) fak *= i; return fak ; } Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 16

14 Rekursive Funktionen (2) Beispiel: Fibonacci-Zahlen: a 0 := a 1 := 1, a n := a n 2 + a n 1 für n 2 int fib_ rekursiv ( int n) { if (n >= 2) return fib_ rekursiv ( n -2) + fib_ rekursiv ( n -1); else return 1; // Abbruch der Rekursion } Rekursion hier sehr ineffizient! fib_rekursiv( n ) erzeugt O(2 n 1 ) Aufrufe von sich selbst. Bei Berechnung von a n wird z.b. a 2 sehr oft neu berechnet. besser: Rekursion durch Iteration ersetzen Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 16

15 Rekursive Funktionen (3) Beispiel: Fibonacci-Zahlen: a 0 := a 1 := 1, a n := a n 2 + a n 1 für n 2 int fib_ iterativ ( int n) { if (n < 2) return 1; } int ak, ak1 = 1, ak2 = 1; // a_k, a_{k -1}, a_{k -2} for ( int k= 2; k <= n; ++ k) { ak = ak2 + ak1 ; // nach Definition ak2 = ak1 ; ak1 = ak; // Variablen shiften } return ak; Iterativer Ansatz ist deutlich effizienter: Aufwand zur Berechnung von a n ist linear in n (nicht exponentiell) a 2 wird genau einmal berechnet (für k=2) Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 16

16 Impliziter und expliziter Cast automatische, implizite Typumwandlung (Cast), leider auch bei Informationsverlust, z.b. int double, float double, int bool oft nützlich, aber manchmal auch gefährlich. Typumwandlung kann auch explizit angefordert werden: int a=2, b =5; double c= a / b, // 0, int - Division! d= double (a) / double (b), // 0.4, C- style cast e= static_cast < double >( b ) / a; // 2.5, C ++ - style cast + impliziter Cast Typumwandlung von/nach string funktioniert (leider) anders, dazu später mehr. Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 16