Informatik 1 ( ) D-MAVT F2011. Operatoren, Auswertungsreihenfolge, Fliesskommazahlen. Yves Brise Übungsstunde 2

Transkript

1 Informatik 1 ( ) D-MAVT F2011 Operatoren, Auswertungsreihenfolge, Fliesskommazahlen

2 Inhalt Ziele: Casting, Typenkonvertierung Mehr Operatoren Fliesskommazahlen Heute nicht (siehe Vorlesung): Character processing, ASCII Konstanten Gültigkeitsbereiche (Scopes) Funktionen

3 To Be Discussed Updates in Ubuntu ausstellen. Gefahr des Systemzusammenbruchs. System Update Manager Settings (Passwort eingeben: Informatik) Häkchen bei Check for updates, Important Security updates und Recommended Updates weg. Probleme mit Vollbildmodus und/oder gemeinsamem Ordner, siehe virtualbox.php Musterlösungen vom letzten Jahr.

4 Explizite Typenkonvertierung Sogenannte cast expressions, übliche Schreibweise: Bsp: type(expr) oder (type)expr int( ) (double)2+1.5f (double)(7/3) Es wird abgerundet Wie unärer Operator Beide Klammern erlaubt Eigentlich besser: static_cast<int>( )

5 rvalues und lvalues Definition Ein lvalue ist ein Ausdruck, der eine Adresse hat (z.b. Variable). Alles andere sind rvalues (z.b. Literal). Die Bezeichnungen kommen daher, dass nur ein Ausdruck mit Adresse auf der linken Seite einer Zuweisung stehen darf (vgl. left und right) Operatoren definieren, ob sie einen lvalue brauchen oder nicht. Ein lvalue kann problemlos in einen rvalue konvertiert werden. Es wird einfach der Wert and der Adresse des lvalue geholt.

6 Zuweisungsoperator lvalue int a; a = 1; Zuweisungsoperator rvalue Zuweisung ist rechts-assoziativ und gibt einen lvalue zurück, Bsp. a = b = 1 a = (b = 1) Es gibt noch die Varianten += -= *= /= %= Bsp. a += 1 a = a + 1 Single Modification Rule Eine Variable darf in einem Ausdruck nur einmal verändert werden, z.b. x = ++x + 1 ist nicht gut.

7 Inkrement und Dekrement int a = 1; ++a; a--; Prefix Inkrement Postfix Dekrement Der Effekt von Inkrement ist, dass er die Variable um eins erhöht, Dekrement erniedrigt die Variable um eins. Prefix: lvalue lvalue, gibt neuen Wert zurück. Postfix: lvalue rvalue, gibt alten Wert zurück. Die Prefix Form ist effizienter. Gibt es nicht nur für int. Besonders interessant auch für eigene Datentypen (Klassen) via Overloading und für Iteratoren.

8 Relationale Operatoren Damit können Vergleiche angestellt werden. Die Operanden sind zwei rvalues des selben Typs, die Rückgabe ist ein bool. Die Operatoren sind ==!= < <= > >= Regel: Relationale Operatoren binden schwächer als aritmethische und stärker als logische. Sind links-assoziativ, Bsp. a < b == c (a < b)== c if (a >= 0) {... } else if (a == 1) {... } else {... }

9 Logische Operatoren Operieren auf Wahrheitswerten (bool). Wir benötigen UND (&&) und ODER ( ) und nicht (!). Regel:! bindet stärker als &&, stärker als Bsp: a&&!b c (a&&(!b)) c Short-circuit Evaluation Ausdrücke werden von links nach rechts ausgewertet. Wenn schon klar ist, wie der Wert des gesamten Ausdrucks ist, wird der zweite Operand nicht mehr ausgewertet. Bsp. x!=0 && 1/x > 0.5 && true false true true false false false false true false true true true false true false! true false false true

10 Die ganze Wahrheit über Operatoren Präzedenz Operator Stelligkeit Assoziativität r/l-value (postfix) 1 links l r 2 static_cast 1 links r r (prefix) 1 rechts l l rechts r r 3! 1 rechts r r 3 (type) 1 rechts r r 5 * / % 2 links r x r r links r x r r 8 < <= > >= 2 links r x r r 9!= == 2 links r x r r 13 && 2 links r x r r 14 2 links r x r r 16 += -= *= /= %= = 2 rechts l x r l

11 Auswertungsreihenfolge Klammerung ergibt Ausdrucksbaum: 9 * celsius / <= 32 + o (((9 * celsius) / 5) + 32) <= (32 + o)

12 Auswertungsreihenfolge Auswertung von den Blättern zur Wurzel... 9 * celsius / <= 32 + o (((9 * celsius) / 5) ) false <= ( o) 0)

13 Auswertungsreihenfolge Gültige Reihenfolge: Jeder Knoten wird erst nach seinen Kindern ausgewertet. Kinder Knoten Vorsicht: Die Reihenfolge ist nicht immer eindeutig bestimmt. Besonders relevant bei effektvollen Operatoren. Bsp. Funktionsaufrufe: f() + g() Guter Ausdruck: Jede gültige Reihenfolge führt zum selben Ergebnis.

14 Schnellübung Klammern & Auswerten! Typ, Wert? int a(2), b(0); float s(1.5f); bool t(true), f(false); a) t = a - 1 < b b) t s > 0 && f c) * 6 / 4 == 3 && 2.1 / 1.3 < 1.8 d) 12 / 6 / 2 * < * 2 > 1 e) 11 * 19 % 21 * 13 % 23 * 3 % 3 f) (++a - 1) / 2 g) a / 2 h) a!= 2 && a - 1!= 1 a + 1 == 3 i) 17 / 2 == 8.5 && 7 * 3 == 21.0 j) s = a = 4 / 5 k) t * s && b == 0 l) int(8.5) - int(7.6) / ++ b

15 Schnellübung Lösung int a(2), b(0); float s(1.5f); bool t(true), f(false); a) t=((a-1)<b); // bool, false b) t ((s>0)&&f); // bool, true c) ((1+((1*6)/4)))==3)&&((2.1/1.3)<1.8); // bool, false d) (((((12/6)/2)*3.0)+1)<4) ((2.0*2)>1); // bool, true e) (((((11*19)%21)*13)%23)*3)%3; // int, 0 f) ((++a)-1)/2; // int, 1 g) (a++)-(1/2); // int, 2 h) ((a!=2)&&((a-1)!=1)) ((a+1)==3); // bool, true i) ((17/2)==8.5)&&((7*3)==21.0); // bool, false j) s=(a=(4/5)); // float, 0.0f k) t (((127.37*s)&&b)==0); // bool, true l) int(8.5)-(int(7.6)/(++b)); // int, 1

16 IEEE754, float, double float: double: ( 1) V 2 E 127 (1.M) ( 1) V 2 E 1023 (1.M)

17 Rechnen mit Fliesskommazahlen 1 Approximation der Euler-Konstante e = i=0 i! // Program: euler.cpp // Approximate Euler's constant e. #include <iostream> int main () { // values for term i, initialized for i = 0 float t = 1.0f; // 1/i! float e = 1.0f; // i-th approximation of e std::cout.precision(10); std::cout << "Approximating the Euler constant...\n"; // steps 1,...,n for (unsigned int i = 1; i < 10; ++i) { e += t /= i; // compact form of t = t / i; e = e + t; std::cout << "Value after term " << i << ": " << e << "\n"; } } return 0; Richtig e=2,

18 Löcher im Wertebereich // Program: diff.cpp // Check subtraction of two floating point numbers #include <iostream> int main() { // Input float n1; std::cout << "First number =? "; std::cin >> n1; float n2; std::cout << "Second number =? "; std::cin >> n2; Beispiel diff.cpp float d; std::cout << "Their difference =? "; std::cin >> d; Eingabe: 1.5 Eingabe: 1.0 Eingabe: 0.5 } // Computation and output std::cout << "Computed difference - input difference = " << n1 - n2 - d << ".\n"; return 0; Ausgabe: 0

19 Löcher im Wertebereich // Program: diff.cpp // Check subtraction of two floating point numbers #include <iostream> int main() { // Input float n1; std::cout << "First number =? "; std::cin >> n1; float n2; std::cout << "Second number =? "; std::cin >> n2; Beispiel diff.cpp float d; std::cout << "Their difference =? "; std::cin >> d; Eingabe: 1.1 Eingabe: 1.0 Eingabe: 0.1 } // Computation and output std::cout << "Computed difference - input difference = " << n1 - n2 - d << ".\n"; return 0; Ausgabe: e-08

20 IEEE754, Goldene Regel 1 Regel 1: Teste keine Fliesskommazahlen auf Gleichheit, wenn mindestens eine das Ergebnis einer Rundungsoperation ist. for (float i = 0.1; i!= 1.0; i += 0.1){ std::cout << i << \n ; } Klingt theoretisch gut, aber in der Praxis Endlosschleife, da (0.1) dez ˆ= ( ) bin

21 IEEE754, Goldene Regel 2 Regel 2: Vermeide die Addition von Zahlen sehr unterschiedlicher Grösse. Beispiel Harmonische Zahl n 1 H n = lim i H n ln n n i=1 Berechnung vorwärts: H n = n Berechnung rückwärts: H n = 1 n + 1 Siehe harmonic.cpp... n

22 IEEE754, Goldene Regel 3, Auslöschung Regel 3: Vermeide die Subtraktion von Zahlen sehr ähnlicher Grösse. Bsp. Berechnung der Diskriminante einer quadratischen Gleichung: b2 4ac Problem: Die involvierten Zahlen können das Ergebins einer Rundungsoperation sein. Die Subtraktion kann den Fehler von wenig signifikanten Bits zu signifikatnen Bits erheben. Das Resultat kann um Grössenordnungen falsch sein.

23 Excel 2007 Bug Excel sagt: Richtiges Resultat: = = 65535? Eigentlich nur Anzeigefehler: Eine von zwölf (laut Micorsoft) Zahlen nahe an 65535, die falsch ins Dezimalsystem umgewandelt werden. Intern wird richtig weiter gerechnet. Aber: Die zugrunde liegende Ursache ist natürlich, dass die Berechnung mit Fliesskommazahlen nicht exakt durchführbar ist.

24 string vs. std::cin #include <iostream> #include <string> int main() { string s; std::cin >> s; } Problem: Es wird nicht genügend Speicher alloziert. string s( abcdef... ); string s(10, 0 ); std::cout << s.capacity(); s.reserve(10);

25 Tipps zur Serie 2 Aufgaben 1, 2 und 3: Siehe Schnellübungen. Aufgaben 4: Schritt für Schritt durchgehen und von Hand ausrechnen. Aufgaben 5: Einlesen von 4 Werten (std::cin) und dann einfache Berechnung mit Ausgabe. Versuchen Sie, das Programm selbsterklärend zu machen, d.h. sinnvolle Anfragen an den Benutzer zu stellen. Und: Kommentare nicht vergessen!