Structs, Referenztypen und Const-Typen

Transkript

1 Structs, Referenztypen und Const-Typen

2 Rechnen mit rationalen Zahlen o Rationale Zahlen (Q) sind von der Form n/d, mit n und d ausz o C++ hat keinen eingebauten Typ für rationale Zahlen

3 Rechnen mit rationalen Zahlen o Rationale Zahlen (Q) sind von der Form n/d, mit n und d ausz o C++ hat keinen eingebauten Typ für rationale Zahlen Ziel: Wir bauen uns selbst einen C++ Typ für rationale Zahlen!

4 Rechnen mit rationalen Zahlen So könnte es aussehen // Program: userational2.c // Add two rational numbers. #include <iostream> #include <IFM/rational.h> int main () { // input std::cout << "Rational number r:\n"; ifm::rational r; std::cin >> r; std::cout << "Rational number s:\n"; ifm::rational s; std::cin >> s; // computation and output std::cout << "Sum is " << r + s << ".\n"; } return 0;

5 Ein erstes Struct // Program: userational.c // Add two rational numbers. #include <iostream> // the new type rational struct rational { int n; int d; // INV: d!= 0 };...

6 Ein erstes Struct // Program: userational.c // Add two rational numbers. #include <iostream> // the new type rational struct rational { int n; int d; // INV: d!= 0 };... Ein struct definiert einen neuen Typ, dessen Wertebereich das kartesische Produkt der Wertebereiche existierender Typen ist (hier int int).

7 Ein erstes Struct // Program: userational.c // Add two rational numbers. #include <iostream> // the new type rational struct rational { int n; int d; // INV: d!= 0 }; Invariante : Spezifiziert gültige Kombinationen von Werten (informell)... Ein struct definiert einen neuen Typ, dessen Wertebereich das kartesische Produkt der Wertebereiche existierender Typen ist (hier int int).

8 Ein erstes Struct // Program: userational.c // Add two rational numbers. #include <iostream> // the new type rational struct rational { int n; int d; // INV: d!= 0 };... Ein struct definiert einen Typ, keine Variable!

9 Ein erstes Struct // Program: userational.c // Add two rational numbers. #include <iostream> // the new type rational struct rational { int n; int d; // INV: d!= 0 }; Bedeutung: jedes Objekt des neuen Typs ist durch zwei Objekte vom Typ int repräsentiert, die die Namen n und d tragen.... Ein struct definiert einen Typ, keine Variable!

10 Ein erstes Struct : Funktionalität // Program: userational.c // Add two rational numbers. #include <iostream> // the new type rational struct rational { int n; int d; // INV: d!= 0 }; // POST: return value is the sum of a and b rational add (rational a, rational b) { } rational result; result.n = a.n * b.d + a.d * b.n; result.d = a.d * b.d; return result;

11 Ein erstes Struct : Funktionalität // Program: userational.c // Add two rational numbers. #include <iostream> // the new type rational struct rational { int n; int d; // INV: d!= 0 }; // POST: return value is the sum of a and b rational add (rational a, rational b) { } rational result; result.n = a.n * b.d + a.d * b.n; result.d = a.d * b.d; return result; Mitglieds-Zugriff auf die int- Objekte von a

12 Ein erstes Struct : Funktionalität // Program: userational.c // Add two rational numbers. #include <iostream> // the new type rational struct rational { int n; int d; // INV: d!= 0 }; a + b = Zähler(a) Nenner(b) + Nenner(a) Zähler(b) Nenner(a) Nenner(b) // POST: return value is the sum of a and b rational add (rational a, rational b) { } rational result; result.n = a.n * b.d + a.d * b.n; result.d = a.d * b.d; return result;

13 Ein erstes Struct : Funktionalität // Program: userational.c // Add two rational numbers. #include <iostream> // the new type rational struct rational { int n; int d; // INV: d!= 0 }; a + b = result = Zähler(a) Nenner(b) + Nenner(a) Zähler(b) Nenner(a) Nenner(b) // POST: return value is the sum of a and b rational add (rational a, rational b) { } rational result; result.n = a.n * b.d + a.d * b.n; result.d = a.d * b.d; return result;

14 Ein erstes Struct: Funktionalität // Program: userational.c // Add two rational numbers. #include <iostream> // the new type rational struct rational { int n; int d; // INV: d!= 0 }; Der neue Typ kann wie existierende Typen benutzt werden, z.b. in Variablendeklarationen... // POST: return value is the sum of a and b rational add (rational a, rational b) { } rational result; result.n = a.n * b.d + a.d * b.n; result.d = a.d * b.d; return result;

15 Ein erstes Struct: Funktionalität // Program: userational.c // Add two rational numbers. #include <iostream> // the new type rational struct rational { int n; int d; // INV: d!= 0 }; Der neue Typ kann wie existierende Typen benutzt werden, z.b. in formalen Parameterlisten... // POST: return value is the sum of a and b rational add (rational a, rational b) { } rational result; result.n = a.n * b.d + a.d * b.n; result.d = a.d * b.d; return result;

16 Ein erstes Struct: Funktionalität // Program: userational.c // Add two rational numbers. #include <iostream> // the new type rational struct rational { int n; int d; // INV: d!= 0 }; Der neue Typ kann wie existierende Typen benutzt werden, z.b. in Rückgabetypen... // POST: return value is the sum of a and b rational add (rational a, rational b) { } rational result; result.n = a.n * b.d + a.d * b.n; result.d = a.d * b.d; return result;

17 Ein erstes Struct: Benutzung int main () { // input std::cout << "Rational number r:\n"; rational r; std::cout << " numerator =? "; std::cin >> r.n; std::cout << " denominator =? "; std::cin >> r.d; std::cout << "Rational number s:\n"; rational s; std::cout << " numerator =? "; std::cin >> s.n; std::cout << " denominator =? "; std::cin >> s.d; // computation rational t = add (r, s); // output std::cout << "Sum is " << t.n << "/" << t.d << ".\n"; } return 0;

18 Struct-Definitionen struct T { T1 name1; Name des neuen Typs (Bezeichner) T2 name2;... TN namen; }; Namen der Daten-Mitglieder (Bezeichner) Namen der zugrundeliegenden Typen

19 Struct-Definitionen struct T { T1 name1; T2 name2;... TN namen; }; Namen der zugrundeliegenden Typen Name des neuen Typs (Bezeichner) Namen der Daten-Mitglieder (Bezeichner) Wertebereich von T : T1 T2... TN

20 Struct-Definitionen: Beispiele struct rational_vector_3 { rational x; rational y; rational z; }; Die zugrundeliegenden Typen können fundamentale, aber auch benutzerdefinierte Typen sein.

21 Struct-Definitionen: Beispiele struct extended_int { // represents u if n==false and -u otherwise unsigned int u; // absolute value bool n; // sign bit }; Die zugrundeliegenden Typen können natürlich auch verschieden sein.

22 Structs: Mitglieds-Zugriff Name eines Daten-Mitglieds des Typs T expr.namek Mitglieds-Zugriff-Operator Ausdruck vom Struct-Typ T

23 Structs: Mitglieds-Zugriff Name eines Daten-Mitglieds des Typs T expr.namek Ausdruck vom Typ TK ; Wert ist der Wert des durch namek bezeichneten Objekts. Mitglieds-Zugriff-Operator Ausdruck vom Struct-Typ T

24 Structs: Initialisierung und Zuweisung Initialisierung: rational t = add (r, s);

25 Structs: Initialisierung und Zuweisung Initialisierung: rational t = add (r, s); o t wird mit dem Wert von add (r, s) initialisiert o Initialisierung erfolgt separat für jedes Daten-Mitglied

26 Structs: Initialisierung und Zuweisung Initialisierung: t.n = add (r, s).n; t.d = add (r, s).d; rational t = add (r, s); o t wird mit dem Wert von add (r, s) initialisiert o Initialisierung erfolgt separat für jedes Daten-Mitglied

27 Structs: Initialisierung und Zuweisung Default-Initialisierung: rational t; o Daten-Mitglieder von t werden defaultinitialisiert o für Daten-Mitglieder fundamentaler Typen passiert nichts (Wert undefiniert)

28 Structs: Initialisierung und Zuweisung Zuweisung: o rational t; t = add (r, s); t wird default-initialisiert o der Wert von add (r,s) wird t zugewiesen (wieder separat für jedes Daten-Mitglied)

29 Structs: Gleichheitstest? Für jeden fundamentalen Typ gibt es die Vergleichsoperatoren == und!=, aber nicht für Structs! Warum?

30 Structs: Gleichheitstest? Für jeden fundamentalen Typ gibt es die Vergleichsoperatoren == und!=, aber nicht für Structs! Warum? o Mitgliedsweiser Vergleich ergibt im allgemeinen keinen Sinn,...

31 Structs: Gleichheitstest? Für jeden fundamentalen Typ gibt es die Vergleichsoperatoren == und!=, aber nicht für Structs! Warum? o Mitgliedsweiser Vergleich ergibt im allgemeinen keinen Sinn,... o...denn dann wäre z.b. 2/3 4/6

32 Structs: Syntaktischer vs. semantischer Wertebereich o syntaktischer Wertebereich von T ist das kartesische Produkt T1 T2... TN

33 Structs: Syntaktischer vs. semantischer Wertebereich o syntaktischer Wertebereich von T ist das kartesische Produkt T1 T2... TN Typ rational: int int

34 Structs: Syntaktischer vs. semantischer Wertebereich o syntaktischer Wertebereich von T ist das kartesische Produkt T1 T2... TN o semantischer Wertebereich von T ergibt sich aus der Bedeutung eines N-Tupels (t1, t2,..., tn)

35 Structs: Syntaktischer vs. semantischer Wertebereich o syntaktischer Wertebereich von T ist das kartesische Produkt T1 T2... TN o semantischer Wertebereich von T ergibt sich aus der Bedeutung eines N-Tupels (t1, t2,..., tn) Typ rational: (n, d) bedeutet n/d

36 Structs: Syntaktischer vs. semantischer Wertebereich o syntaktischer Wertebereich von T ist das kartesische Produkt T1 T2... TN o semantischer Wertebereich von T ergibt sich aus der Bedeutung eines N-Tupels (t1, t2,..., tn) o mitgliedsweise Operationen beissen sich oft mit dem semantischen Wertebereich

37 Benutzerdefinierte Operatoren Anstatt rational t = add (r, s); würden wir lieber rational t = r + s; schreiben.

38 Benutzerdefinierte Operatoren Anstatt rational t = add (r, s); würden wir lieber rational t = r + s; schreiben. Dies geht mit Operator-Überladung.

39 Funktions- und Operator- Überladung Verschiedene Funktionen können den gleichen Namen haben.

40 Funktions- und Operator- Überladung Verschiedene Funktionen können den gleichen Namen haben. // POST: returns a * a rational square (rational a); // POST: returns a * a extended_int square (extended_int a);

41 Funktions- und Operator- Überladung Verschiedene Funktionen können den gleichen Namen haben. // POST: returns a * a rational square (rational a); // POST: returns a * a extended_int square (extended_int a); Der Compiler findet anhand der Aufrufparameter heraus, welche gemeint ist.

42 Operator-Überladung o Operatoren sind spezielle Funktionen und können auch überladen werden

43 Operator-Überladung o Operatoren sind spezielle Funktionen und können auch überladen werden o Name des Operators op : operatorop

44 Operator-Überladung o Operatoren sind spezielle Funktionen und können auch überladen werden o Name des Operators op : operatorop o wir wissen schon, dass z.b. operator+ für verschiedene Typen existiert

45 Additionsoperator für rationale Zahlen Bisher: // POST: return value is the sum of a and b rational add (rational a, rational b) { }... rational result; result.n = a.n * b.d + a.d * b.n; result.d = a.d * b.d; return result; rational t = add (r, s);

46 Additionsoperator für rationale Zahlen Neu: // POST: return value is the sum of a and b rational operator+ (rational a, rational b) { }... rational result; result.n = a.n * b.d + a.d * b.n; result.d = a.d * b.d; return result; rational t = r + s;

47 Additionsoperator für rationale Zahlen Neu: // POST: return value is the sum of a and b rational operator+ (rational a, rational b) { }... rational result; result.n = a.n * b.d + a.d * b.n; result.d = a.d * b.d; return result; rational t = r + s; Infix-Notation

48 Additionsoperator für rationale Zahlen Neu: // POST: return value is the sum of a and b rational operator+ (rational a, rational b) { }... rational result; result.n = a.n * b.d + a.d * b.n; result.d = a.d * b.d; return result; Äquivalent, aber unpraktisch: funktionale Notation rational t = operator+ (r, s);

49 Andere binäre arithmetische Operatoren für rationale Zahlen // POST: return value is the difference of a and b rational operator- (rational a, rational b); // POST: return value is the product of a and b rational operator* (rational a, rational b); // POST: return value is the quotient of a and b // PRE: b!= 0 rational operator/ (rational a, rational b);

50 Unäres Minus Hat gleiches Symbol wie binäres Minus, aber nur einen Parameter: // POST: return value is -a rational operator- (rational a) { a.n = -a.n; return a; }

51 Relationale Operatoren Sind für Structs nicht eingebaut, können aber so definiert werden, dass sie den semantischen Wertebereich respektieren. // POST: return value is true if and only if a == b bool operator== (rational a, rational b) { return a.n * b.d == a.d * b.n; }

52 Arithmetische Zuweisungen Wir wollen z.b. schreiben: rational r; r.n = 1; r.d = 2; // 1/2 rational s; s.n = 1; s.d = 3; // 1/3 r += s; std::cout << r.n << "/" << r.d << "\n"; // 5/6

53 Arithmetische Zuweisungen Wir wollen z.b. schreiben: rational r; r.n = 1; r.d = 2; // 1/2 rational s; s.n = 1; s.d = 3; // 1/3 operator+= r += s; std::cout << r.n << "/" << r.d << "\n"; // 5/6

54 Das Problem mit operator+= Erster Versuch: rational operator+= (rational a, rational b) { a.n = a.n * b.d + a.d * b.n; a.d *= b.d; return a; }

55 Das Problem mit operator+= Erster Versuch: rational operator+= (rational a, rational b) { a.n = a.n * b.d + a.d * b.n; a.d *= b.d; return a; } Das funktioniert nicht!

56 Das Problem mit operator+= Erster Versuch: rational operator+= (rational a, rational b) { } a.n = a.n * b.d + a.d * b.n; a.d *= b.d; return a; Das funktioniert nicht! Problem: Der Ausdruck r += s hat zwar den gewünschten Wert r + s, aber nicht den gewünschten Effekt der Veränderung von r, weil ein Funktionsaufruf die Werte der Aufrufparameter nicht ändert.

57 Das Problem mit operator+= o Wir müssen Funktionen in die Lage versetzen, die Werte ihrer Aufrufparameter ändern zu können!

58 Das Problem mit operator+= o Wir müssen Funktionen in die Lage versetzen, die Werte ihrer Aufrufparameter ändern zu können! o Dazu brauchen wir kein neues Konzept auf der Funktionenseite, sondern eine neue Klasse von Typen.

59 Das Problem mit operator+= o Wir müssen Funktionen in die Lage versetzen, die Werte ihrer Aufrufparameter ändern zu können! o Dazu brauchen wir kein neues Konzept auf der Funktionenseite, sondern eine neue Klasse von Typen. Referenztypen

60 Referenztypen: Definition T & gelesen als T-Referenz zugrundeliegender Typ

61 Referenztypen: Definition T & gelesen als T-Referenz zugrundeliegender Typ o T & hat gleichen Wertebereich und gleiche Funktionalität wie T,...

62 Referenztypen: Definition T & gelesen als T-Referenz zugrundeliegender Typ o T & hat gleichen Wertebereich und gleiche Funktionalität wie T,... o... nur die Initialisierungs- und Zuweisungssemantik ist anders.

63 Referenztypen: Initialisierung o Eine Variable mit Referenztyp (eine Referenz) kann nur mit einem L-Wert initialisiert werden o die Variable wird dabei ein Alias des L- Werts (ein anderer Name für das Objekt hinter dem L-Wert)

64 Referenztypen: Initialisierung und Zuweisung Beispiel: int i = 5; int& j = i; // j becomes an alias of i j = 6; // changes the value of i std::cout << i << "\n"; // outputs 6

65 Referenztypen: Initialisierung und Zuweisung Beispiel: int i = 5; int& j = i; // j becomes an alias of i j = 6; // changes the value of i std::cout << i << "\n"; // outputs 6 i Speicher 5

66 Referenztypen: Initialisierung Beispiel: int i = 5; int& j = i; // j becomes an alias of i j = 6; // changes the value of i std::cout << i << "\n"; // outputs 6 i j Speicher 5

67 Referenztypen: Zuweisung Beispiel: int i = 5; int& j = i; // j becomes an alias of i j = 6; // changes the value of i std::cout << i << "\n"; // outputs 6 i j Speicher 6

68 Referenztypen: Zuweisung Beispiel: int i = 5; int& j = i; // j becomes an alias of i j = 6; // changes the value of i std::cout << i << "\n"; // outputs 6 Zuweisung erfolgt an das Objekt hinter der Referenz i j Speicher 6

69 Referenztypen: Initialisierung und Zuweisung Beispiel: int i = 5; int& j = i; // j becomes an alias of i j = 6; // changes the value of i std::cout << i << "\n"; // outputs 6 i j Speicher 6

70 Referenztypen: Initialisierung Referenzen können auch mit Referenzen initialisiert werden: int i = 5; int& j = i; // j becomes an alias of i int& k = j; // k becomes another alias of i

71 Referenztypen: Realisierung o Intern wird ein Wert vom Typ T & durch die Adresse eines Objekts vom Typ T repräsentiert

72 Referenztypen: Realisierung o Intern wird ein Wert vom Typ T & durch die Adresse eines Objekts vom Typ T repräsentiert int& j; // error: j must be an alias of something int& k = 5; // error: the literal 5 has no address

73 Call by Reference o Referenztypen erlauben Funktionen, die Werte ihre Aufrufparameter zu ändern: void increment (int& i) { ++i; } int main () { int j = 5; increment (j); std::cout << j << "\n"; // outputs 6 } return 0;

74 Call by Reference o Referenztypen erlauben Funktionen, die Werte ihre Aufrufparameter zu ändern: void increment (int& i) { ++i; } int main () { int j = 5; increment (j); std::cout << j << "\n"; // outputs 6 j return 0; } 5

75 Call by Reference o Referenztypen erlauben Funktionen, die Werte ihre Aufrufparameter zu ändern: void increment (int& i) { ++i; } int main () { int j = 5; increment (j); std::cout << j << "\n"; // outputs 6 j return 0; } 5

76 Call by Reference o Referenztypen erlauben Funktionen, die Werte ihre Aufrufparameter zu ändern: void increment (int& i) { // i becomes alias of call parameter ++i; } Initialisierung der formalen Parameter int main () { int j = 5; increment (j); std::cout << j << "\n"; // outputs 6 j i return 0; } 5

77 Call by Reference o Referenztypen erlauben Funktionen, die Werte ihre Aufrufparameter zu ändern: void increment (int& i) { // i becomes alias of call parameter ++i; } int main () { int j = 5; increment (j); std::cout << j << "\n"; // outputs 6 j i return 0; } 6

78 Call by Reference o Referenztypen erlauben Funktionen, die Werte ihre Aufrufparameter zu ändern: void increment (int& i) { // i becomes alias of call parameter ++i; } int main () { int j = 5; increment (j); std::cout << j << "\n"; // outputs 6 j i return 0; } 6

79 Call by Value / Reference o formaler Parameter hat Referenztyp: call by reference formaler Parameter wird (intern) mit der Adresse des Aufrufparameters (L-Wert) initialisiert und wird damit zu einem Alias

80 Call by Value / Reference o formaler Parameter hat Referenztyp: call by reference formaler Parameter wird (intern) mit der Adresse des Aufrufparameters (L-Wert) initialisiert und wird damit zu einem Alias o formaler Parameter hat keinen Referenztyp: call by value formaler Parameter wird mit dem Wert des Aufrufparameters (R-Wert) initialisiert und wird damit zu einer Kopie

81 Return by Value / Reference o Auch der Rückgabetyp einer Funktion kann ein Referenztyp sein (return by reference) o In diesem Fall ist der Funktionsausfruf selbst ein L-Wert

82 Return by Value / Reference o Auch der Rückgabetyp einer Funktion kann ein Referenztyp sein (return by reference) o In diesem Fall ist der Funktionsausfruf selbst ein L-Wert int& increment (int& i) { return ++i; } exakt die Semantik des Pre-Inkrements:

83 Die Lösung für operator+= Bisher (funktioniert nicht): rational operator+= (rational a, rational b) { a.n = a.n * b.d + a.d * b.n; a.d *= b.d; return a; }

84 Die Lösung für operator+= Neu: // POST: b has been added to a; // return value is the new value of a rational& operator+= (rational& a, rational b) { } a.n = a.n * b.d + a.d * b.n; a.d *= b.d; return a; Der L-Wert a wird um den Wert von b inkrementiert und als L-Wert zurückgegeben

85 Ein-/Ausgabeoperatoren o können auch überladen werden! Bisher: std::cout << "Sum is " << t.n << "/" << t.d << "\n";

86 Ein-/Ausgabeoperatoren o können auch überladen werden! Bisher: std::cout << "Sum is " << t.n << "/" << t.d << "\n"; Neu (gewünscht): std::cout << "Sum is " << t << "\n";

87 Ein-/Ausgabeoperatoren o können auch überladen werden! Das kann wie folgt erreicht werden: // POST: a has been written to o std::ostream& operator<< (std::ostream& o, rational r) { return o << r.n << "/" << r.d; }

88 Ein-/Ausgabeoperatoren o können auch überladen werden! Das kann wie folgt erreicht werden: // POST: a has been written to o std::ostream& operator<< (std::ostream& o, rational r) { return o << r.n << "/" << r.d; } schreibt r auf den Ausgabestrom o und gibt diesen als L-Wert zurück

89 Temporäre Objekte Was ist hier falsch? int& foo (int i) { return i; }

90 Temporäre Objekte Was ist hier falsch? int& foo (int i) { return i; } Funktionswert vom Typ int& wird Alias des formalen Parameters, dessen Speicherdauer aber nach Auswertung des Funktionsausfrufes endet.

91 Temporäre Objekte Was ist hier falsch? int& foo (int i) { return i; } Funktionswert vom Typ int& wird Alias des formalen Parameters, dessen Speicherdauer aber nach Auswertung des Funktionsausfrufes endet. int i = 3; int& j = foo(i); // j refers to expired object std::cout << j << "\n"; // undefined behavior

92 Temporäre Objekte Was ist hier falsch? int& foo (int i) { return i; } Aufrufstapel int i = 3; int& j = foo(i); // j refers to expired object std::cout << j << "\n"; // undefined behavior

93 Temporäre Objekte Was ist hier falsch? int& foo (int i) { Wert des Aufrufparameters kommt auf den Aufrufstapel } return i; Aufrufstapel 3 i int i = 3; int& j = foo(i); // j refers to expired object std::cout << j << "\n"; // undefined behavior

94 Temporäre Objekte Was ist hier falsch? int& foo (int i) { return i; } i wird als Referenz zurückgegeben... Aufrufstapel 3 i int i = 3; int& j = foo(i); // j refers to expired object std::cout << j << "\n"; // undefined behavior

95 Temporäre Objekte Was ist hier falsch? int& foo (int i) { return i; }... und verschwindet vom Aufrufstapel Aufrufstapel Speicher freigegeben int i = 3; int& j = foo(i); // j refers to expired object std::cout << j << "\n"; // undefined behavior

96 Temporäre Objekte Was ist hier falsch? int& foo (int i) { return i; } j wird mit Rückgabereferenz initialisiert Aufrufstapel Speicher freigegeben j int i = 3; int& j = foo(i); // j refers to expired object std::cout << j << "\n"; // undefined behavior

97 Temporäre Objekte Was ist hier falsch? int& foo (int i) { return i; } Wert von j wird ausgegeben Aufrufstapel Speicher freigegeben j int i = 3; int& j = foo(i); // j refers to expired object std::cout << j << "\n"; // undefined behavior

98 Die Referenz-Richtlinie Wenn man eine Referenz erzeugt, muss diese mindestens so lange leben wie das Objekt, auf das sie verweist.

99 Const-Typen Vorschlag des Effizienzfanatikers: // POST: return value is the sum of a and b rational operator+ (rational& a, rational& b) { rational result; result.n = a.n * b.d + a.d * b.n; result.d = a.d * b.d; return result; }

100 Const-Typen Vorschlag des Effizienzfanatikers: // POST: return value is the sum of a and b rational operator+ (rational& a, rational& b) { } rational result; result.n = a.n * b.d + a.d * b.n; result.d = a.d * b.d; return result; Beim Aufruf muss jeweils nur eine Addresse kopiert werden anstatt zwei int s (Einsparung wird dramatisch bei grossen Structs)

101 Const-Typen Vorschlag des Effizienzfanatikers: // POST: return value is the sum of a and b rational operator+ (rational& a, rational& b) { } rational result; result.n = a.n * b.d + a.d * b.n; result.d = a.d * b.d; return result; Nachteil: Operator kann nur mit L-Werten aufgerufen werden (das kann in der konkreten Anwendung aber ausreichend sein).

102 Const-Typen Vorschlag des Effizienzfanatikers ist aber sogar gefährlich!

103 Const-Typen Vorschlag des Effizienzfanatikers ist aber sogar gefährlich! Unäres Minus: // POST: return value is -a rational operator- (rational a) { a.n = -a.n; return a; }

104 Const-Typen Vorschlag des Effizienzfanatikers ist aber sogar gefährlich! Unäres Minus: // POST: return value is -a rational operator- (rational& a) { a.n = -a.n; return a; } Vorschlag

105 Const-Typen Vorschlag des Effizienzfanatikers ist aber sogar gefährlich! Unäres Minus: // POST: return value is -a rational operator- (rational& a) { a.n = -a.n; return a; } Vorschlag Der Ausdruck a hat den gewünschten Wert, aber einen unerwünschten Effekt: der Wert von a wird verändert!

106 Const-Typen o verhindern solche unbeabsichtigten Wertänderungen (semantische Fehler), indem sie den semantischen Fehler für den Compiler erkennbar machen o machen damit das Leben des Programmierers einfacher (nicht jeder will das, siehe Real Programmers Don t Use Pascal )

107 Const-Typen: Definition const T gelesen als const-t o zugrundeliegender Typ const T hat gleichen Wertebereich und gleiche Funktionalität wie T,... o... aber Ausdrücke dieses Typs sind im Wert nicht veränderbar.

108 Const-Typen: Beispiele rational operator- (const rational& a) { a.n = -a.n; // error: a was promised to be constant return a; }

109 Const-Typen: Beispiele rational operator- (const rational& a) { a.n = -a.n; // error: a was promised to be constant return a; } const int n = 5; n = 6; // error: n was promised to be constant

110 Was genau ist konstant? Betrachte L-Wert vom Typ const T (R-Werte sind ohnehin konstant) o Fall 1: T ist kein Referenztyp

111 Was genau ist konstant? Betrachte L-Wert vom Typ const T (R-Werte sind ohnehin konstant) o Fall 1: T ist kein Referenztyp Dann verweist der L-Wert auf ein konstantes Objekt. const int n = 5; int& i = n; // error: const-qualification is discarded i = 6;

112 Was genau ist konstant? Betrachte L-Wert vom Typ const T (R-Werte sind ohnehin konstant) o Fall 1: T ist kein Referenztyp Dann verweist der L-Wert auf ein konstantes Objekt. const int n = 5; int& i = n; // error: const-qualification is discarded i = 6; Schummelversuch wird vom Compiler erkannt!

113 Was genau ist konstant? Betrachte L-Wert vom Typ const T (R-Werte sind ohnehin konstant) o Fall 2: T ist Referenztyp Dann verweist der L-Wert auf ein Objekt, dessen Wert zwar veränderbar ist, aber nicht durch diesen Alias.

114 Was genau ist konstant? Betrachte L-Wert vom Typ const T (R-Werte sind ohnehin konstant) o Fall 2: T ist Referenztyp int n = 5; Dann verweist der L-Wert auf ein Objekt, dessen Wert zwar veränderbar ist, aber nicht durch diesen L-Wert. const int& i = n; // i becomes a non-modifiable alias of n int& j = n; // j becomes a modifiable alias of n i = 6; // error: n is modified through const reference j = 6; // ok: n receives value 6

115 Const-Referenzen o haben Typ const T & (= const (T & )) o können auch mit R-Werten initialisiert werden (Compiler erzeugt temporäres Objekt ausreichender Lebensdauer)

116 Const-Referenzen o haben Typ const T & (= const (T & )) o können auch mit R-Werten initialisiert werden (Compiler erzeugt temporäres Objekt ausreichender Lebensdauer) o sind die eierlegende Wollmilchsau: const T & r = lvalue ; r wird mit Adresse von lvalue initialisert (effizient)

117 Const-Referenzen o haben Typ const T & (= const (T & )) o können auch mit R-Werten initialisiert werden (Compiler erzeugt temporäres Objekt ausreichender Lebensdauer) o sind die eierlegende Wollmilchsau: const T & r = rvalue ; r wird mit Adresse eines temporären Objekts vom Wert des rvalue initialisert (flexibel)

118 Const-Referenzen o sichere Version von operator+ mit Const-Referenzen: // POST: return value is the sum of a and b rational operator+ (const rational& a, const rational& b) { } rational result; result.n = a.n * b.d + a.d * b.n; result.d = a.d * b.d; return result;

119 Const-Referenzen o sichere Version von operator+ mit Const-Referenzen: // POST: return value is the sum of a and b rational operator+ (const rational& a, const rational& b) { } rational result; result.n = a.n * b.d + a.d * b.n; result.d = a.d * b.d; return result; Bemerkung: T kann als Parametertyp oft durch const T & ersetzt werden; dies lohnt sich aber nicht für fundamentale Typen oder kleine Structs.

120 Rückgabe von Const-Referenzen o Erseten von T durch const T & ist meistens nicht gut bei Rückgabetypen Korrekte Version: rational operator+ (const rational& a, const rational& b) { } rational result; result.n = a.n * b.d + a.d * b.n; result.d = a.d * b.d; return result;

121 Rückgabe von Const-Referenzen o Erseten von T durch const T & ist meistens nicht gut bei Rückgabetypen Inkorrekte Version: const rational& operator+ (const rational& a, const rational& b) { } rational result; result.n = a.n * b.d + a.d * b.n; result.d = a.d * b.d; return result;

122 Rückgabe von Const-Referenzen o Erseten von T durch const T & ist meistens nicht gut bei Rückgabetypen Inkorrekte Version: const rational& operator+ (const rational& a, const rational& b) { } rational result; result.n = a.n * b.d + a.d * b.n; result.d = a.d * b.d; return result; Hier wird Referenz auf ein temporäres Objekt zurückgegeben

123 Die Const-Richtlinie Benutze const, wann immer es geht (Sicherheit) und einen Unterschied macht! o es macht immer einen Unterschied bei Referenztypen

124 Die Const-Richtlinie Benutze const, wann immer es geht (Sicherheit) und einen Unterschied macht! o es macht immer einen Unterschied bei Referenztypen const T & erlaubt R-Wert-Initialisierung, T & nicht

125 Die Const-Richtlinie Benutze const, wann immer es geht (Sicherheit) und einen Unterschied macht! o es macht immer einen Unterschied bei Referenztypen o andernfalls macht es einen Unterschied bei Variablen, deren Gültigkeitsbereich mehr als 10 Zeilen umfasst