o Alphabet Σ ( Beispiel: {F, +, -} ) o P: Σ -> Σ * eine Produktion o w 0 = F o w 1 = F+F+ o w 2 = F+F++F+F++ o w 3 = F+F++F+F+++F+F++F+F+++ o...

Transkript

1 Fraktale rekursv zechnen Defnton o Alphabet Σ ( Bespel: F, +, - ) o Σ * = Menge aller endlchen Wörter über Σ ( Bespel: F+F+ st n Σ * ) o P: Σ -> Σ * ene Produkton Bespel: P(F) = F+F+ P(+) = + P(- ) = - Defnton o Alphabet Σ ( Bespel: F, +, - ) o Σ * = Menge aller endlchen Wörter über Σ ( Bespel: F+F+ st n Σ * ) o P: Σ -> Σ * ene Produkton o s aus Σ * en Startwort ( Bespel: F) Def.: (Σ, P, s) st Lndenmayer-System. De beschrebenen Wörter De von (Σ, P, s) beschrebenen Wörter: o w 0 = F o w 1 = F+F+ o w 2 = F+F++F+F++ o w 3 = F+F++F+F+++F+F++F+F+++ o w 2 entsteht aus w 1 durch Ersetzen aller Symbole mttels P. F F+F Turtle-Grafk Turtle-Grafk: o Schldkröte mt Poston und Rchtung o versteht folgende Kommandos: o F: gehe enen Schrtt n dene Rchtung (und markere hn n Schwarz) o + / - : drehe dch um 90 o gegen / m UZS Turtle-Grafk Zechnen enes Wortes : F+F+ 1

2 Turtle-Grafk Zechnen enes Wortes : Turtle-Grafk Zechnen enes Wortes : F+F+ F+F+ Turtle-Grafk Zechnen enes Wortes : Turtle-Grafk Zechnen enes Wortes : F+F+ F+F+ Rekursves Zechnen Zechnen von w : o w 0 = F o w 1 = F+F+ o w 2 = F+F++F+F++ o w 3 = F+F++F+F+++F+F++F+F+++ o F+F+ = w 1 (F) w =: w (F) = w -1 (F) w -1 (+) w -1 (F) w -1 (+) + + Rekursves Zechnen Zechnen von w : o w 0 = F o w 1 = F+F+ o w 2 = F+F++F+F++ o w 3 = F+F++F+F+++F+F++F+F+++ o w =: w (F) = w -1 (F) + w -1 (F) + 2

3 Rekursves Zechnen (Bespel) // POST: the word w_^f s drawn vod f (const unsgned nt ) f ( == 0) fm::forward(); // F else f(-1); // w_-1^f fm::left(90); // + f(-1); // w_-1^f fm::left(90); // + Befehle für Turtle-Grafk (aus der lbwndow-bblothek) w (F) = w -1 (F)+w -1 (F)+ Rekursves Zechnen (Bespel) nt man () std::cout << "Number of teratons =? "; unsgned std::cn >> n; // draw w_n = w_n(f) f(n); Erweterungen Erweterungen (Drachen) Neue Symbole (ohne Interpretaton n Turtle-Grafk): Bespel Drachenkurve: o s = X o P(X) = X+YF+, P(Y) = -FX-Y o w = w (X) = w -1 (X)+w -1 (Y)F+ // POST: w_^x s drawn vod x (const unsgned nt ) f ( > 0) x(-1); // w_-1^x fm::left(90); // + y(-1); // w_-1^y fm::forward(); // F fm::left(90); // + // POST: w_^y s drawn vod y (const unsgned nt ) f ( > 0) fm::rght(90); // - fm::forward(); // F x(-1); // w_-1^x fm::rght(90); // - y(-1); // w_-1^y w (X) = w -1 (X)+w -1 (Y)F+ w (Y) = -Fw -1 (X)-w -1 (Y) Drachen Programm dragon.cpp : Erweterungen Drehwnkel α kann fre gewählt werden. Bespel Schneeflocke: o o o o α = 60 o s = F++F++F P(F) = F-F++F-F w = w (F++F++F) = w (F)++w (F)++w (F) w -1 (F)-w -1 (F)++w -1 (F)-w -1 (F) 3

4 Schneeflocke // POST: the word w_^f s drawn vod f (const unsgned nt ) f ( == 0) fm::forward(); // F else f(-1); // w_-1^f fm::rght(60); // - f(-1); // w_-1^f fm::left(120); // ++ f(-1); // w_-1^f fm::rght(60); // - f(-1); // w_-1^f Schneeflocke nt man () std::cout << "Number of teratons =? "; unsgned std::cn >> n; // draw w_n = w_n^f++w_n^f++w_n^f f(n); // w_n^f fm::left(120); // ++ f(n); // w_n^f fm::left(120); // ++ f(n); // w_n^f w (F) = w -1 (F)-w -1 (F)++w -1 (F)-w -1 (F) Schneeflocke Programm snowflake.cpp : Structs und Referenztypen Ratonale Zahlen, Struct- Defnton, Referenztypen, Operator-Überladung Rechnen mt ratonalen Zahlen o Ratonale Zahlen (Q) snd von der Form n/d, mt n und d aus Z o C++ hat kenen engebauten Typ für ratonale Zahlen Zel: Wr bauen uns selbst enen C++ Typ für ratonale Zahlen! Rechnen mt ratonalen Zahlen So könnte (wrd) es aussehen // Program: useratonal2.cpp #nclude ratonal.cpp nt man () // nput std::cout << "Ratonal number r:\n"; fm::ratonal r; std::cn >> r; std::cout << "Ratonal number s:\n"; fm::ratonal s; std::cn >> s; // computaton and output std::cout << "Sum s " << r + s << ".\n"; 4

5 En erstes Struct En erstes Struct struct ratonal ; struct ratonal ; Invarante : Spezfzert gültge Kombnatonen von Werten (nformell) En struct defnert enen neuen Typ, dessen Werteberech das kartessche Produkt der Wertebereche exsterender Typen st (her nt nt). En erstes Struct En erstes Struct : Funktonaltät struct ratonal ; Bedeutung: edes Obekt des neuen Typs st durch zwe Obekte vom Typ nt repräsentert, de de Namen n und d tragen. En struct defnert enen Typ, kene Varable! struct ratonal ; ratonal add (const ratonal a, const ratonal b) Mtgleds-Zugrff auf de nt- Obekte von a En erstes Struct : Funktonaltät En erstes Struct : Funktonaltät struct ratonal ; a + b = Zähler(a) Nenner(b) + Nenner(a) Zähler(b) Nenner(a) Nenner(b) struct ratonal ; a + b = result = Zähler(a) Nenner(b) + Nenner(a) Zähler(b) Nenner(a) Nenner(b) ratonal add (const ratonal a, const ratonal b) ratonal add (const ratonal a, const ratonal b) 5

6 En erstes Struct: Funktonaltät En erstes Struct: Funktonaltät struct ratonal ; Der neue Typ kann we exsterende Typen benutzt werden, z.b. n Varablendeklaratonen ratonal add (const ratonal a, const ratonal b) struct ratonal ; Der neue Typ kann we exsterende Typen benutzt werden, z.b. n formalen Argumentlsten ratonal add (const ratonal a, const ratonal b) En erstes Struct: Funktonaltät En erstes Struct: Benutzung struct ratonal ; Der neue Typ kann we exsterende Typen benutzt werden, z.b. n Rückgabetypen ratonal add (const ratonal a, const ratonal b) nt man () // nput std::cout << "Ratonal number r:\n"; ratonal r; std::cout << " numerator =? "; std::cn >> r.n; std::cout << " denomnator =? "; std::cn >> r.d; std::cout << "Ratonal number s:\n"; ratonal s; std::cout << " numerator =? "; std::cn >> s.n; std::cout << " denomnator =? "; std::cn >> s.d; // computaton const ratonal t = add (r, s); // output std::cout << "Sum s " << t.n << "/" << t.d << ".\n"; Struct-Defntonen Struct-Defntonen: Bespele Name des neuen Typs (Bezechner) struct T T1 name1; T2 name2; Namen der Daten-Mtgleder (Bezechner) TN namen; ; Werteberech von T : Namen der zugrundelegenden Typen T1 T2 TN struct ratonal_vector_3 ratonal x; ratonal y; ratonal z; ; De zugrundelegenden Typen können fundamentale, aber auch benutzerdefnerte Typen sen. 6

7 Struct-Defntonen: Bespele Structs: Mtgleds-Zugrff struct extended_nt // represents u f n==false and -u otherwse unsgned nt u; // absolute value bool n; // sgn bt ; expr.namek Name enes Daten-Mtgleds des Typs T Ausdruck vom Typ TK ; Wert st der Wert des durch namek bezechneten Obekts. De zugrundelegenden Typen können natürlch auch verscheden sen. Ausdruck vom Struct-Typ T Mtgleds-Zugrff-Operator Structs: Intalserung und Zuwesung Structs: Intalserung und Zuwesung Intalserung: t.n = add (r, s).n; t.d = add (r, s).d; Default-Intalserung: ratonal t = add (r, s); o t wrd mt dem Wert von add (r, s) ntalsert o Intalserung erfolgt separat für edes Daten-Mtgled ratonal t; o Daten-Mtgleder von t werden defaultntalsert o für Daten-Mtgleder fundamentaler Typen passert nchts (Wert undefnert) Structs: Intalserung und Zuwesung Zuwesung: ratonal t; t = add (r, s); o t wrd default-ntalsert o der Wert von add (r,s) wrd t zugewesen (weder separat für edes Daten-Mtgled) Structs und Felder o Felder können auch Mtgleder von Structs sen struct ratonal_vector_3 ; ratonal v[3]; o Durch Verpacken n en Struct kann das Koperen von Feldern errecht werden! 7

8 Structs und Felder Structs: Glechhetstest? #nclude<ostream> struct pont double coord[2]; ; nt man() pont p; p.coord[0] = 1; p.coord[1] = 2; pont q = p; // Her wrd en Feld mt zwe Elementen kopert std::cout << q.coord[0] << " " // 1 << q.coord[1] << "\n"; // 2 Für eden fundamentalen Typ gbt es de Verglechsoperatoren == und!=, aber ncht für Structs! Warum? o Mtgledsweser Verglech ergbt m allgemenen kenen Snn, o denn dann wäre z.b. 2/3 4/6 Benutzerdefnerte Operatoren Anstatt ratonal t = add (r, s); würden wr leber ratonal t = r + s; schreben. Des geht mt Operator-Überladung. Funktons- und Operator- Überladung Verschedene Funktonen können den glechen Namen haben. // POST: returns a * a ratonal square (ratonal a); // POST: returns a * a extended_nt square (extended_nt a); Der Compler fndet anhand der Aufruf- Argumente heraus, welche gement st. Operator-Überladung o Operatoren snd spezelle Funktonen und können auch überladen werden o Name des Operators op : operatorop o wr wssen schon, dass z.b. operator+ für verschedene Typen exstert Addtonsoperator für ratonale Zahlen Bsher: ratonal add (const ratonal a, const ratonal b) const ratonal t = add (r, s); 8

9 Addtonsoperator für ratonale Zahlen Neu: ratonal operator+ (const ratonal a, const ratonal b) const ratonal t = r + s; Addtonsoperator für ratonale Zahlen Neu: ratonal operator+ (const ratonal a, const ratonal b) Infx-Notaton const ratonal t = r + s; Addtonsoperator für ratonale Zahlen Neu: ratonal operator+ (const ratonal a, const ratonal b) Äquvalent, aber unpraktsch: funktonale Notaton const ratonal t = operator+ (r, s); Andere bnäre arthmetsche Operatoren für ratonale Zahlen // POST: return value s the dfference of a and b ratonal operator- (ratonal a, ratonal b); // POST: return value s the product of a and b ratonal operator* (ratonal a, ratonal b); // POST: return value s the quotent of a and b // PRE: b!= 0 ratonal operator/ (ratonal a, ratonal b); Unäres Mnus Hat gleches Symbol we bnäres Mnus, aber nur en Argument: Relatonale Operatoren Snd für Structs ncht engebaut, können aber defnert werden: // POST: return value s -a ratonal operator- (ratonal a) a.n = -a.n; return a; // POST: return value s true f and only f a == b bool operator== (const ratonal a, const ratonal b) return a.n * b.d == a.d * b.n; 9

10 Arthmetsche Zuwesungen Wr wollen z.b. schreben: Das Problem mt operator+= Erster Versuch: ratonal r; r.n = 1; r.d = 2; // 1/2 ratonal s; s.n = 1; s.d = 3; operator+= // 1/3 r += s; std::cout << r.n << "/" << r.d << "\n"; // 5/6 ratonal operator+= (ratonal a, const ratonal b) a.n = a.n * b.d + a.d * b.n; a.d *= b.d; return a; Das funktonert ncht! Problem: Der Ausdruck r += s hat zwar den gewünschten Wert r + s, aber ncht den gewünschten Effekt der Veränderung von r, wel en Funktonsaufruf de Werte der Aufrufargumente ncht ändert. Das Problem mt operator+= o Wr müssen Funktonen n de Lage versetzen, de Werte hrer Aufrufargumente ändern zu können! o Dazu brauchen wr ken neues Konzept auf der Funktonensete, sondern ene neue Klasse von Typen. Referenztypen Referenztypen: Defnton T & gelesen als T-Referenz zugrundelegender Typ o T & hat glechen Werteberech und gleche Funktonaltät we T, o nur de Intalserungs- und Zuwesungssemantk st anders. Referenztypen: Intalserung o Ene Varable mt Referenztyp (ene Referenz) kann nur mt enem L-Wert ntalsert werden o de Varable wrd dabe en Alas des L- Werts (en anderer Name für das Obekt hnter dem L-Wert) Referenztypen: Intalserung und Zuwesung Bespel: nt = 5; nt& = ; // becomes an alas of = 6; // changes the value of std::cout << << "\n"; // outputs 6 Specher 5 10

11 Referenztypen: Intalserung Bespel: Referenztypen: Zuwesung Bespel: nt = 5; nt& = ; // becomes an alas of nt = 5; nt& = ; // becomes an alas of = 6; // changes the value of std::cout << << "\n"; // outputs 6 = 6; // changes the value of std::cout << << "\n"; // outputs 6 Specher 5 Specher 6 Referenztypen: Zuwesung Referenzen snd mplzte Zeger (aber enfacher und scherer) Bespel: nt = 5; nt& = ; // becomes an alas of = 6; // changes the value of std::cout << << "\n"; // outputs 6 Mt Referenzen: nt = 5; nt& = ; = 6; std::cout << << "\n"; Mt Zegern: nt = 5; nt* = &; * = 6; std::cout << << "\n"; Zuwesung erfolgt an das Obekt hnter der Referenz Specher 6 Specher 6 Referenztypen: Realserung o Intern wrd en Wert vom Typ T & durch de Adresse enes Obekts vom Typ T repräsentert nt& ; // error: must be an alas of somethng nt& k = 5; // error: the lteral 5 has no address Call by Reference o Referenztypen erlauben Funktonen, de Werte hre Aufrufargumente zu ändern: vod ncrement (nt& ) ++; nt man () nt = 5; ncrement (); std::cout << << "\n"; // outputs

12 Call by Reference o Referenztypen erlauben Funktonen, de Werte hre Aufrufargumente zu ändern: Call by Reference o Referenztypen erlauben Funktonen, de Werte hre Aufrufargumente zu ändern: vod ncrement (nt& ) ++; vod ncrement (nt& ) // becomes alas of call argument ++; Intalserung der formalen Parameter nt man () nt = 5; ncrement (); std::cout << << "\n"; // outputs 6 nt man () nt = 5; ncrement (); std::cout << << "\n"; // outputs Call by Reference o Referenztypen erlauben Funktonen, de Werte hre Aufrufargumente zu ändern: Call by Reference o Referenztypen erlauben Funktonen, de Werte hre Aufrufparameter zu ändern: vod ncrement (nt& ) // becomes alas of call argument ++; vod ncrement (nt& ) // becomes alas of call parameter ++; nt man () nt = 5; ncrement (); std::cout << << "\n"; // outputs 6 nt man () nt = 5; ncrement (); std::cout << << "\n"; // outputs Call by Value / Reference o formales Argument hat Referenztyp: call by reference formales Argument wrd (ntern) mt der Adresse des Aufrufarguments (L-Wert) ntalsert und wrd damt zu enem Alas o formales Argument hat kenen Referenztyp: call by value formales Argument wrd mt dem Wert des Aufrufparameters (R-Wert) ntalsert und wrd damt zu ener Kope Return by Value / Reference o Auch der Rückgabetyp ener Funkton kann en Referenztyp sen (return by reference) o In desem Fall st der Funktonsausfruf selbst en L-Wert nt& ncrement (nt& ) return ++; exakt de Semantk des Prä-Inkrements: 12

13 De Lösung für operator+= Bsher (funktonert ncht): De Lösung für operator+= Neu: ratonal operator+= (ratonal a, const ratonal b) a.n = a.n * b.d + a.d * b.n; a.d *= b.d; return a; // POST: b has been added to a; // return value s the new value of a ratonal& operator+= (ratonal& a, const ratonal b) a.n = a.n * b.d + a.d * b.n; a.d *= b.d; return a; Der L-Wert a wrd um den Wert von b nkrementert und als L-Wert zurückgegeben En-/Ausgabeoperatoren o können auch überladen werden! En-/Ausgabeoperatoren o können auch überladen werden! Bsher: std::cout << "Sum s " << t.n << "/" << t.d << "\n"; Neu (gewünscht): std::cout << "Sum s " << t << "\n"; Das kann we folgt errecht werden: // POST: r has been wrtten to o std::ostream& operator<< (std::ostream& o, const ratonal r) return o << r.n << "/" << r.d; schrebt r auf den Ausgabestrom o und gbt desen als L-Wert zurück En-/Ausgabeoperatoren o können auch überladen werden! // PRE: starts wth a ratonal number of the form // n/d // POST: r has been read from std::stream& operator>> (std::stream&, ratonal& r) char c; // separatng character / return >> r.n >> c >> r.d; Zwschenzel errecht! nt man () // nput std::cout << "Ratonal number r:\n"; fm::ratonal r; std::cn >> r; std::cout << "Ratonal number s:\n"; fm::ratonal s; std::cn >> s; // computaton and output std::cout << "Sum s " << r + s << ".\n"; operator<< operator+ operator>> lest r aus dem Engabestrom und gbt desen als L-Wert zurück 13