Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ (...
-
Upload
raban-rassier -
Category
Documents
-
view
118 -
download
0
Transcript of Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ (...
![Page 1: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/1.jpg)
Lindenmayer-Systeme: Fraktale rekursiv zeichnen
![Page 2: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/2.jpg)
Lindenmayer-Systeme: Definition
o Alphabet Σ ( Beispiel: {F, +, -} )
![Page 3: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/3.jpg)
Lindenmayer-Systeme: Definition
o Alphabet Σ ( Beispiel: {F, +, -} )o Σ* = Menge aller endlichen Wörter
über Σ ( Beispiel: F+F+ ist in Σ* )
![Page 4: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/4.jpg)
Lindenmayer-Systeme: Definition
o Alphabet Σ ( Beispiel: {F, +, -} )o Σ* = Menge aller endlichen Wörter
über Σ ( Beispiel: F+F+ ist in Σ* )o P: Σ -> Σ* eine Produktion
![Page 5: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/5.jpg)
Lindenmayer-Systeme: Definition
o Alphabet Σ ( Beispiel: {F, +, -} )o Σ* = Menge aller endlichen Wörter
über Σ ( Beispiel: F+F+ ist in Σ* )o P: Σ -> Σ* eine Produktion Beispiel:
P(F) = F+F+
P(+) = +
P(- ) = -
![Page 6: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/6.jpg)
Lindenmayer-Systeme: Definition
o Alphabet Σ ( Beispiel: {F, +, -} )o Σ* = Menge aller endlichen Wörter
über Σ ( Beispiel: F+F+ ist in Σ* )o P: Σ -> Σ* eine Produktiono s aus Σ* ein Startwort ( Beispiel: F)
![Page 7: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/7.jpg)
Lindenmayer-Systeme: Definition
o Alphabet Σ ( Beispiel: {F, +, -} )o Σ* = Menge aller endlichen Wörter
über Σ ( Beispiel: F+F+ ist in Σ* )o P: Σ -> Σ* eine Produktiono s aus Σ* ein Startwort ( Beispiel: F)Def.: (Σ, P, s) ist Lindenmayer-
System.
![Page 8: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/8.jpg)
Lindenmayer-Systeme: Die beschriebenen Wörter
Die von (Σ, P, s) beschriebenen Wörter:o w0 = F
o w1 = F+F+
o w2 = F+F++F+F++
o w3 = F+F++F+F+++F+F++F+F+++o ...
![Page 9: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/9.jpg)
Lindenmayer-Systeme: Die beschriebenen Wörter
Die von (Σ, P, s) beschriebenen Wörter:o w0 = F
o w1 = F+F+
o w2 = F+F++F+F++
o w3 = F+F++F+F+++F+F++F+F+++o ...wi entsteht aus wi-1 durch Ersetzen aller Symbole
mittels P.
![Page 10: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/10.jpg)
Lindenmayer-Systeme: Die beschriebenen Wörter
Die von (Σ, P, s) beschriebenen Wörter:o w0 = F
o w1 = F+F+
o w2 = F+F++F+F++
o w3 = F+F++F+F+++F+F++F+F+++o ...w2 entsteht aus w1 durch Ersetzen aller Symbole
mittels P.F F+F
++ - -+
![Page 11: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/11.jpg)
Lindenmayer-Systeme: Turtle-Grafik
Turtle-Grafik:o Schildkröte mit Position und
Richtung
![Page 12: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/12.jpg)
Lindenmayer-Systeme: Turtle-Grafik
Turtle-Grafik:o Schildkröte mit Position und Richtung
o versteht folgende Kommandos:o F: gehe einen Schritt in deine Richtung
(und markiere ihn in Schwarz)o + / - : drehe dich um 90o gegen / im UZS
![Page 13: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/13.jpg)
Lindenmayer-Systeme:Turtle-Grafik
“Zeichnen eines Wortes”:
F+F+
![Page 14: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/14.jpg)
Lindenmayer-Systeme: Turtle-Grafik
“Zeichnen eines Wortes”:
F+F+
![Page 15: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/15.jpg)
Lindenmayer-Systeme: Turtle-Grafik
“Zeichnen eines Wortes”:
F+F+
![Page 16: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/16.jpg)
Lindenmayer-Systeme: Turtle-Grafik
“Zeichnen eines Wortes”:
F+F+
![Page 17: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/17.jpg)
Lindenmayer-Systeme: Turtle-Grafik
“Zeichnen eines Wortes”:
F+F+
![Page 18: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/18.jpg)
Zeichnen von wi:
o w0 = F
o w1 = F+F+
o w2 = F+F++F+F++
o w3 = F+F++F+F+++F+F++F+F+++o ...
Lindenmayer-Systeme: Rekursives Zeichnen
w2 (F) w2
(F)w2 (+)w3
=: w3 (F) =
w2 (+)
![Page 19: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/19.jpg)
Zeichnen von wi:
o w0 = F
o w1 = F+F+
o w2 = F+F++F+F++
o w3 = F+F++F+F+++F+F++F+F+++o ...
Lindenmayer-Systeme: Rekursives Zeichnen
wi-1 (F) wi-1
(F)wi-1 (+)wi
=: wi (F) = wi-1 (+)
![Page 20: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/20.jpg)
Zeichnen von wi:
o w0 = F
o w1 = F+F+
o w2 = F+F++F+F++
o w3 = F+F++F+F+++F+F++F+F+++o ...
Lindenmayer-Systeme: Rekursives Zeichnen
wi-1 (F) wi-1
(F)wi-1 (+)wi
=: wi (F) = wi-1 (+)
F+F+ = w1(F)
+ +
![Page 21: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/21.jpg)
Zeichnen von wi:
o w0 = F
o w1 = F+F+
o w2 = F+F++F+F++
o w3 = F+F++F+F+++F+F++F+F+++o ...
Lindenmayer-Systeme: Rekursives Zeichnen
wi-1 (F) wi-1
(F) +wi =: wi (F) = +
![Page 22: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/22.jpg)
Lindenmayer-Systeme: Rekursives Zeichnen (Beispiel)// POST: the word w_i^F is drawnvoid f (const unsigned int i) { if (i == 0) ifm::forward(); // F else { f(i-1); // w_{i-1}^F ifm::left(90); // + f(i-1); // w_{i-1}^F ifm::left(90); // + }}
wi (F) = wi-1 (F)+wi-1 (F)
+
![Page 23: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/23.jpg)
Lindenmayer-Systeme: Rekursives Zeichnen (Beispiel)// POST: the word w_i^F is drawnvoid f (const unsigned int i) { if (i == 0) ifm::forward(); // F else { f(i-1); // w_{i-1}^F ifm::left(90); // + f(i-1); // w_{i-1}^F ifm::left(90); // + }}
wi (F) = wi-1 (F)+wi-1 (F)
+
Befehle für Turtle-Grafik (aus der libwindow-Bibliothek)
![Page 24: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/24.jpg)
Lindenmayer-Systeme: Rekursives Zeichnen (Beispiel)int main () { std::cout << "Number of iterations =? "; unsigned int n; std::cin >> n;
// draw w_n = w_n(F) f(n);
return 0;}
![Page 25: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/25.jpg)
Lindenmayer-Systeme: Erweiterungen
Neue Symbole (ohne Interpretation in Turtle-Grafik):
Beispiel Drachenkurve:o s = Xo P(X) = X+YF+, P(Y) = -FX-Yo wi = wi (X) = wi-1(X)+wi-1(Y)F+
![Page 26: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/26.jpg)
Lindenmayer-Systeme: Erweiterungen (Drachen)// POST: w_i^X is drawnvoid x (const unsigned int i) { if (i > 0) { x(i-1); // w_{i-1}^X ifm::left(90); // + y(i-1); // w_{i-1}^Y ifm::forward(); // F ifm::left(90); // + }}
// POST: w_i^Y is drawnvoid y (const unsigned int i) { if (i > 0) { ifm::right(90); // - ifm::forward(); // F x(i-1); // w_{i-1}^X ifm::right(90); // - y(i-1); // w_{i-1}^Y }}
wi (X) = wi-1 (X)+wi-1
(Y)F+
wi (Y) = -Fwi-1 (X)-wi-1 (Y)
![Page 27: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/27.jpg)
Lindenmayer-Systeme: Drachen
Programm dragon.cpp :
![Page 28: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/28.jpg)
Lindenmayer-Systeme: Erweiterungen
Drehwinkel α kann frei gewählt werden.
Beispiel Schneeflocke: o α = 60o
o s = F++F++Fo P(F) = F-F++F-Fo wi = wi(F++F++F) = wi(F)++wi(F)+
+wi(F)wi-1(F)-wi-1(F)++wi-1(F)-wi-1(F)
![Page 29: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/29.jpg)
Lindenmayer-Systeme: Schneeflocke// POST: the word w_i^F is drawnvoid f (const unsigned int i) { if (i == 0) ifm::forward(); // F else { f(i-1); // w_{i-1}^F ifm::right(60); // - f(i-1); // w_{i-1}^F ifm::left(120); // ++ f(i-1); // w_{i-1}^F ifm::right(60); // - f(i-1); // w_{i-1}^F }}
wi (F) = wi-1 (F)-wi-1 (F)++wi-1 (F)-wi-1
(F)
![Page 30: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/30.jpg)
Lindenmayer-Systeme: Schneeflockeint main () { std::cout << "Number of iterations =? "; unsigned int n; std::cin >> n; // draw w_n = w_n^F++w_n^F++w_n^F f(n); // w_n^F ifm::left(120); // ++ f(n); // w_n^F ifm::left(120); // ++ f(n); // w_n^F
return 0;}
![Page 31: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/31.jpg)
Lindenmayer-Systeme: Schneeflocke
Programm snowflake.cpp :
![Page 32: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/32.jpg)
Structs und Referenztypen
Rationale Zahlen, Struct-Definition, Referenztypen,
Operator-Überladung
![Page 33: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/33.jpg)
Rechnen mit rationalen Zahlen
o Rationale Zahlen (Q) sind von der Form n/d, mit n und d aus Z
o C++ hat keinen “eingebauten” Typ für rationale Zahlen
![Page 34: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/34.jpg)
Rechnen mit rationalen Zahlen
o Rationale Zahlen (Q) sind von der Form n/d, mit n und d aus Z
o C++ hat keinen “eingebauten” Typ für rationale Zahlen
Ziel: Wir bauen uns selbst einen C++ Typ für rationale Zahlen!
![Page 35: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/35.jpg)
Rechnen mit rationalen ZahlenSo könnte (wird) es aussehen// Program: userational2.cpp// Add two rational numbers.#include <iostream>#include “rational.cpp”
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;}
![Page 36: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/36.jpg)
Ein erstes Struct// Program: userational.cpp
// Add two rational numbers.
#include <iostream>
// the new type rational
struct rational {
int n;
int d; // INV: d != 0
};
...
![Page 37: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/37.jpg)
Ein erstes Struct// Program: userational.cpp
// 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 Werte-bereiche existierender Typen ist (hier int × int).
![Page 38: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/38.jpg)
Ein erstes Struct// Program: userational.cpp
// 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 Werte-bereiche existierender Typen ist (hier int × int).
Invariante : Spezifiziert gültige Kombinationen von Werten (informell)
![Page 39: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/39.jpg)
Ein erstes Struct// Program: userational.cpp
// 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 !
![Page 40: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/40.jpg)
Ein erstes Struct// Program: userational.cpp
// 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 !
Bedeutung: jedes Objekt des neuen Typs ist durch zwei Ob-jekte vom Typ int repräsentiert, die die Namen n und d tragen.
![Page 41: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/41.jpg)
Ein erstes Struct : Funktionalität// Program: userational.cpp
// 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 (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;
}
![Page 42: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/42.jpg)
Ein erstes Struct : Funktionalität// Program: userational.cpp
// 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 (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;
}
Mitglieds-Zugriff auf die int- Objekte von a
![Page 43: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/43.jpg)
Ein erstes Struct : Funktionalität// Program: userational.cpp
// 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 (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;
}
a + b =
Zähler(a) · Nenner(b) + Nenner(a) · Zähler(b)
Nenner(a) · Nenner(b)
![Page 44: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/44.jpg)
Ein erstes Struct : Funktionalität// Program: userational.cpp
// 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 (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;
}
a + b = result =
Zähler(a) · Nenner(b) + Nenner(a) · Zähler(b)
Nenner(a) · Nenner(b)
![Page 45: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/45.jpg)
Ein erstes Struct: Funktionalität// Program: userational.cpp
// 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 (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;
}
Der neue Typ kann wie existierende Typen benutzt werden, z.B. in
Variablendeklarationen...
![Page 46: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/46.jpg)
Ein erstes Struct: Funktionalität// Program: userational.cpp
// 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 (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;
}
Der neue Typ kann wie existierende Typen benutzt werden, z.B. in
formalen Argumentlisten...
![Page 47: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/47.jpg)
Ein erstes Struct: Funktionalität// Program: userational.cpp
// 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 (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;
}
Der neue Typ kann wie existierende Typen benutzt werden, z.B. in
Rückgabetypen...
![Page 48: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/48.jpg)
Ein erstes Struct: Benutzungint 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
const rational t = add (r, s);
// output
std::cout << "Sum is " << t.n << "/" << t.d << ".\n";
return 0;
}
![Page 49: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/49.jpg)
Struct-Definitionen
struct T {
T1 name1;
T2 name2;
...
TN nameN;
};
Name des neuen Typs (Bezeichner)
Namen der zugrundeliegenden Typen
Namen der Daten-Mitglieder (Bezeichner)
![Page 50: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/50.jpg)
Struct-Definitionen
struct T {
T1 name1;
T2 name2;
...
TN nameN;
};
Name des neuen Typs (Bezeichner)
Namen der zugrundeliegenden Typen
Namen der Daten-Mitglieder (Bezeichner)
Wertebereich von T :
T1 × T2 × ... × TN
![Page 51: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/51.jpg)
Struct-Definitionen: Beispielestruct rational_vector_3 {
rational x;
rational y;
rational z;
};
Die zugrundeliegenden Typen können fundamentale, aber auch benutzerdefinierte Typen sein.
![Page 52: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/52.jpg)
Struct-Definitionen: Beispielestruct 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.
![Page 53: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/53.jpg)
Structs: Mitglieds-Zugriff
expr.nameK
Ausdruck vom Struct-Typ T
Mitglieds-Zugriff-Operator
Name eines Daten-Mitglieds des Typs T
![Page 54: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/54.jpg)
Structs: Mitglieds-Zugriff
expr.nameK
Ausdruck vom Struct-Typ T
Mitglieds-Zugriff-Operator
Name eines Daten-Mitglieds des Typs T
Ausdruck vom Typ TK ; Wert ist der Wert des durch nameK bezeichneten Objekts.
![Page 55: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/55.jpg)
Structs: Initialisierung und Zuweisung
Initialisierung:
rational t = add (r, s);
![Page 56: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/56.jpg)
Structs: Initialisierung und Zuweisung
Initialisierung:
o t wird mit dem Wert von add (r, s) initialisiert
o Initialisierung erfolgt separat für jedes Daten-Mitglied
rational t = add (r, s);
![Page 57: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/57.jpg)
Structs: Initialisierung und Zuweisung
Initialisierung:
o t wird mit dem Wert von add (r, s) initialisiert
o Initialisierung erfolgt separat für jedes Daten-Mitglied
rational t = add (r, s);
“t.n = add (r, s).n;
t.d = add (r, s).d;”
![Page 58: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/58.jpg)
Structs: Initialisierung und Zuweisung
Default-Initialisierung:
o Daten-Mitglieder von t werden default-initialisiert
o für Daten-Mitglieder fundamentaler Typen passiert nichts (Wert undefiniert)
rational t;
![Page 59: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/59.jpg)
Structs: Initialisierung und Zuweisung
Zuweisung:
o t wird default-initialisierto der Wert von add (r,s) wird t
zugewiesen (wieder separat für jedes Daten-Mitglied)
rational t;t = add (r, s);
![Page 60: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/60.jpg)
Structs und Felder
o Felder können auch Mitglieder von Structs sein
![Page 61: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/61.jpg)
Structs und Felder
o Felder können auch Mitglieder von Structs sein
struct rational_vector_3 {
rational v[3];
};
![Page 62: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/62.jpg)
Structs und Felder
o Felder können auch Mitglieder von Structs sein
o Durch Verpacken in ein Struct kann das Kopieren von Feldern erreicht werden!
struct rational_vector_3 {
rational v[3];
};
![Page 63: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/63.jpg)
Structs und Felder#include<iostream>
struct point { double coord[2];};
int main(){ point p; p.coord[0] = 1; p.coord[1] = 2;
point q = p; // Hier wird ein Feld mit zwei Elementen kopiert std::cout << q.coord[0] << " " // 1
<< q.coord[1] << "\n"; // 2
return 0;}
![Page 64: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/64.jpg)
Structs: Gleichheitstest?
Für jeden fundamentalen Typ gibt es die
Vergleichsoperatoren == und != , aber
nicht für Structs! Warum?
![Page 65: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/65.jpg)
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,...
![Page 66: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/66.jpg)
Structs: Gleichheitstest?
Für jeden fundamentalen Typ gibt es die
Vergleichsoperatoren == und != , abernicht für Structs! Warum?o Mitgliedsweiser Vergleich ergibt im
allgemeinen keinen Sinn,...o ...denn dann wäre z.B. 2/3 ≠ 4/6
![Page 67: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/67.jpg)
Benutzerdefinierte Operatoren
Anstatt
würden wir lieber
schreiben.
rational t = add (r, s);
rational t = r + s;
![Page 68: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/68.jpg)
Benutzerdefinierte Operatoren
Anstatt
würden wir lieber
schreiben.
Dies geht mit Operator-Überladung.
rational t = add (r, s);
rational t = r + s;
![Page 69: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/69.jpg)
Funktions- und Operator-Überladung
Verschiedene Funktionen können den
gleichen Namen haben.
![Page 70: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/70.jpg)
Funktions- und Operator-Überladung
Verschiedene Funktionen können den
gleichen Namen haben.// POST: returns a * a rational square (rational a);
// POST: returns a * aextended_int square (extended_int a);
![Page 71: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/71.jpg)
Funktions- und Operator-Überladung
Verschiedene Funktionen können dengleichen Namen haben.
Der Compiler findet anhand der Aufruf-Argumente heraus, welche gemeint ist.
// POST: returns a * a rational square (rational a);
// POST: returns a * aextended_int square (extended_int a);
![Page 72: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/72.jpg)
Operator-Überladung
o Operatoren sind spezielle Funktionen und können auch überladen werden
![Page 73: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/73.jpg)
Operator-Überladung
o Operatoren sind spezielle Funktionen und können auch überladen werden
o Name des Operators op :operatorop
![Page 74: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/74.jpg)
Operator-Überladung
o Operatoren sind spezielle Funktionen und können auch überladen werden
o Name des Operators op :
o wir wissen schon, dass z.B. operator+ für verschiedene Typen existiert
operatorop
![Page 75: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/75.jpg)
Additionsoperator für rationale Zahlen
Bisher: // POST: return value is the sum of a and b
rational add (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;
}
...
const rational t = add (r, s);
![Page 76: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/76.jpg)
Additionsoperator für rationale Zahlen
Neu: // 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;
}
...
const rational t = r + s;
![Page 77: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/77.jpg)
Additionsoperator für rationale Zahlen
Neu: // 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;
}
...
const rational t = r + s;
Infix-Notation
![Page 78: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/78.jpg)
Additionsoperator für rationale Zahlen
Neu: // 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;
}
...
const rational t = operator+ (r, s); Äquivalent, aber unpraktisch: funktionale Notation
![Page 79: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/79.jpg)
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);
![Page 80: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/80.jpg)
Unäres Minus
Hat gleiches Symbol wie binäres Minus,
aber nur ein Argument:
// POST: return value is -a
rational operator- (rational a)
{
a.n = -a.n;
return a;
}
![Page 81: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/81.jpg)
Relationale Operatoren
Sind für Structs nicht “eingebaut”, können
aber definiert werden:
// POST: return value is true if and only if a == b
bool operator== (const rational a, const rational b)
{
return a.n * b.d == a.d * b.n;
}
![Page 82: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/82.jpg)
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
![Page 83: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/83.jpg)
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
operator+=
![Page 84: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/84.jpg)
Das Problem mit operator+=
Erster Versuch:
rational operator+=
(rational a, const rational b)
{
a.n = a.n * b.d + a.d * b.n;
a.d *= b.d;
return a;
}
![Page 85: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/85.jpg)
Das Problem mit operator+=
Erster Versuch:
rational operator+=
(rational a, const rational b)
{
a.n = a.n * b.d + a.d * b.n;
a.d *= b.d;
return a;
}
Das funktioniert nicht!
![Page 86: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/86.jpg)
Das Problem mit operator+=
Erster Versuch:
rational operator+=
(rational a, const 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 ge-wünschten Wert r + s, aber nicht den gewünschten Effekt der Veränderung von r, weil ein Funktions-aufruf die Werte der Aufrufargumente nicht ändert.
![Page 87: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/87.jpg)
Das Problem mit operator+=
o Wir müssen Funktionen in die Lage versetzen, die Werte ihrer Aufruf-argumente ändern zu können!
![Page 88: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/88.jpg)
Das Problem mit operator+=
o Wir müssen Funktionen in die Lage versetzen, die Werte ihrer Aufruf-argumente ändern zu können!
o Dazu brauchen wir kein neues Konzept auf der Funktionenseite, sondern eine neue Klasse von Typen.
![Page 89: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/89.jpg)
Das Problem mit operator+=
o Wir müssen Funktionen in die Lage versetzen, die Werte ihrer Aufruf-argumente ändern zu können!
o Dazu brauchen wir kein neues Konzept auf der Funktionenseite, sondern eine neue Klasse von Typen.
Referenztypen
![Page 90: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/90.jpg)
Referenztypen: Definition
T &
zugrundeliegender Typ
gelesen als “T-Referenz”
![Page 91: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/91.jpg)
Referenztypen: Definition
o T & hat gleichen Wertebereich und gleiche Funktionalität wie T ,...
T &
zugrundeliegender Typ
gelesen als “T-Referenz”
![Page 92: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/92.jpg)
Referenztypen: Definition
o T & hat gleichen Wertebereich und gleiche Funktionalität wie T ,...
o ... nur die Initialisierungs- und Zuweisungssemantik ist anders.
T &
zugrundeliegender Typ
gelesen als “T-Referenz”
![Page 93: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/93.jpg)
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)
![Page 94: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/94.jpg)
Referenztypen: Initialisierung und Zuweisung
Beispiel:
int i = 5;int& j = i; // j becomes an alias of i
j = 6; // changes the value of istd::cout << i << "\n"; // outputs 6
![Page 95: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/95.jpg)
Referenztypen: Initialisierung und Zuweisung
Beispiel:
int i = 5;int& j = i; // j becomes an alias of i
j = 6; // changes the value of istd::cout << i << "\n"; // outputs 6
Speicher
i
5
![Page 96: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/96.jpg)
Referenztypen: Initialisierung
Beispiel:
int i = 5;int& j = i; // j becomes an alias of i
j = 6; // changes the value of istd::cout << i << "\n"; // outputs 6
Speicher
i
5
j
![Page 97: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/97.jpg)
Referenztypen: Zuweisung
Beispiel:
int i = 5;int& j = i; // j becomes an alias of i
j = 6; // changes the value of istd::cout << i << "\n"; // outputs 6
Speicher
i
6
j
![Page 98: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/98.jpg)
Referenztypen: Zuweisung
Beispiel:
int i = 5;int& j = i; // j becomes an alias of i
j = 6; // changes the value of istd::cout << i << "\n"; // outputs 6
Speicher
i
6
jZuweisung erfolgt an das Objekt hinter der Referenz
![Page 99: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/99.jpg)
Referenzen sind implizite Zeiger (aber einfacher und sicherer)
Mit Referenzen:
int i = 5;int& j = i;
j = 6; std::cout << i << "\n";
Mit Zeigern:
int i = 5;int* j = &i;
*j = 6; std::cout << i << "\n";
Speicher
i
6
j
![Page 100: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/100.jpg)
Referenztypen: Realisierung
o Intern wird ein Wert vom Typ T & durch die Adresse eines Objekts vom Typ T repräsentiert
![Page 101: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/101.jpg)
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
![Page 102: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/102.jpg)
Call by Reference
o Referenztypen erlauben Funktionen, die Werte ihre Aufrufargumente zu ändern:
void increment (int& i) { ++i;}
int main () { int j = 5; increment (j); std::cout << j << "\n"; // outputs 6 return 0;}
![Page 103: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/103.jpg)
Call by Reference
o Referenztypen erlauben Funktionen, die Werte ihre Aufrufargumente zu ändern:
void increment (int& i) { ++i;}
int main () { int j = 5; increment (j); std::cout << j << "\n"; // outputs 6 return 0;} 5
j
![Page 104: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/104.jpg)
Call by Reference
o Referenztypen erlauben Funktionen, die Werte ihre Aufrufargumente zu ändern:
void increment (int& i) { ++i;}
int main () { int j = 5; increment (j); std::cout << j << "\n"; // outputs 6 return 0;} 5
j
![Page 105: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/105.jpg)
Call by Reference
o Referenztypen erlauben Funktionen, die Werte ihre Aufrufargumente zu ändern:
void increment (int& i) { // i becomes alias of call argument ++i;}
int main () { int j = 5; increment (j); std::cout << j << "\n"; // outputs 6 return 0;} 5
j
Initialisierung der formalen Parameter
i
![Page 106: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/106.jpg)
Call by Reference
o Referenztypen erlauben Funktionen, die Werte ihre Aufrufargumente zu ändern:
void increment (int& i) { // i becomes alias of call argument ++i;}
int main () { int j = 5; increment (j); std::cout << j << "\n"; // outputs 6 return 0;} 6
j i
![Page 107: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/107.jpg)
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 return 0;} 6
j i
![Page 108: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/108.jpg)
Call by Value / Reference
o formales Argument hat Referenztyp:
call by referenceformales Argument wird (intern) mit der Adresse des Aufruf-arguments (L-Wert) initialisiert und wird damit zu einem Alias
![Page 109: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/109.jpg)
Call by Value / Reference
o formales Argument hat Referenztyp: call by reference
o formales Argument hat keinen Referenztyp:
call by valueformales Argument wird mit dem Wert des Aufrufparameters (R-Wert) initialisiert und wird damit zu einer Kopie
formales Argument wird (intern) mit der Adresse des Aufruf-arguments (L-Wert) initialisiert und wird damit zu einem Alias
![Page 110: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/110.jpg)
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
![Page 111: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/111.jpg)
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 Prä-Inkrements:
![Page 112: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/112.jpg)
Die Lösung für operator+=
Bisher (funktioniert nicht):
rational operator+=
(rational a, const rational b)
{
a.n = a.n * b.d + a.d * b.n;
a.d *= b.d;
return a;
}
![Page 113: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/113.jpg)
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, const 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 inkre-mentiert und als L-Wert zurückgegeben
![Page 114: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/114.jpg)
Ein-/Ausgabeoperatoren
o können auch überladen werden!
Bisher:std::cout << "Sum is " << t.n << "/" << t.d << "\n";
![Page 115: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/115.jpg)
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";
![Page 116: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/116.jpg)
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, const rational r)
{
return o << r.n << "/" << r.d;
}
![Page 117: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/117.jpg)
Ein-/Ausgabeoperatoren
o können auch überladen werden!
Das kann wie folgt erreicht werden:
// POST: r has been written to o
std::ostream& operator<<
(std::ostream& o, const rational r)
{
return o << r.n << "/" << r.d;
}
schreibt r auf den Ausgabestrom o und gibt diesen als L-Wert zurück
![Page 118: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/118.jpg)
Ein-/Ausgabeoperatoren
o können auch überladen werden!
// PRE: i starts with a rational number of the form
// “n/d”
// POST: r has been read from i
std::istream& operator>>
(std::istream& i, rational& r)
{
char c; // separating character ‘/’
return i >> r.n >> c >> r.d;
}
liest r aus dem Eingabestrom i und gibt diesen als L-Wert zurück
![Page 119: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/119.jpg)
Zwischenziel erreicht!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;}
![Page 120: Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} )](https://reader036.fdokument.com/reader036/viewer/2022062312/55204d7749795902118cc881/html5/thumbnails/120.jpg)
Zwischenziel erreicht!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;}
operator>>
operator<<operator+