1 / 20

Zusammengesetzte Datentypen

Zusammengesetzte Datentypen. Programmierung I Prof. Dr. Michael Löwe. Inhalt. Stand der Programmiereinführung „Arrays“und Abbildungen Werte und Operationen Ausdrücke, Auswertungen und Statements Iterator für „Arrays“ „Types“ und Produkte Modifikation der Werte, Operationen und Ausdrücke

chaim
Download Presentation

Zusammengesetzte Datentypen

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Zusammengesetzte Datentypen Programmierung I Prof. Dr. Michael Löwe

  2. Inhalt Stand der Programmiereinführung „Arrays“und Abbildungen Werte und Operationen Ausdrücke, Auswertungen und Statements Iterator für „Arrays“ „Types“ und Produkte Modifikation der Werte, Operationen und Ausdrücke Deklarationen und Zugriffspfade Zusammengesetzte Datentypen

  3. mod & | | (1 + 33) (44 mod 2) (-2 * 12) 0 1 33 444 123 2226 0 „“ |Christian| „abc“ & „123“ first( „ab“) falsch  Christian abc „123“ „false“ falsch ES EZ S Z + – * \      rest   EW W T and F T F    first Stand der Programmiereinführung Assignment Composition Conditional Loop Variable-Expressions: Expressions: Values: value[] value value[] Integer Boolean String undefiniert   Types: domain Statements: States: typings [| |] set value compose iterate fixpoint i: 1 b: T s: ab i: 10 b: F s: ab r: cd index: 11 flag: F index: 1000 i: 11 b: F name: Michael Zusammengesetzte Datentypen

  4. Stand der Programmiereinführung Values = ZWS {undefiniert} E = EZEWES Names = {v | v S und firstS(v) ist Buchstabe} States = {z | z: Names  Values ist Abbildung} Types = {Integer, Boolean, String, undefiniert} Typings = {t | t: Names  Types ist Abbildung} domain: Types  2Values ::= Integer Z, Boolean W, String S, undefiniert  {undefiniert} TypedStates = States  Typings value: TypedStates  E Values(value(s, e) geschrieben value[s](e) ) [| |]: St (TypedStates  TypedStates)( [| |](st) geschrieben [|st|] ) Zusammengesetzte Datentypen

  5. Funktionsräume Z Values, W  Values, S Values,undefiniert  Values Wenn T1, T2  Values und undefiniert  T2, dann (1) [T1  T2]  Values Anmerkungen: [T1  T2] = {f | f: T1  T2 ist strikte Abbildung} f ist strikt, wenn f(undefiniert) = undefiniert (2) value: [T1  T2]  T1  T2 ::= value(f, x) = f(x) (3) set: [T1  T2]  T1  T2  [T1  T2] ::= set(f, x, y)(x) = y set(f, x, y)(z) = f(z) falls z  x Zusammengesetzte Datentypen

  6. Feldtypen (1) T<u, o>  Types, wenn u  o  Z und T  Types (2) domain(T<u, o> ) = [{u, ..., o}  domain(T)] Achtung: VB6 erlaubt nur Basistypen für T. Arrays von Arrays nur über Variant. Zusammengesetzte Datentypen

  7. Deklaration von Arrays Wenn n  Names, u, o  EZund T  Types, dann ist Dim n ( u To o) As T  St [| Dim n ( u To o) As T |](s, t) = (set(s, n, Initial(T<u, o>)), set(t, n, T <u, o>), wenn u = value[(s, t)](u)  value[(s, t)](o) = o undefiniert sonst. Initial(T<u, o>)(i) = Initial(T) für alle u  i  o Achtung: VB6 erlaubt nur Konstanten für u und o. Zusammengesetzte Datentypen

  8. Die Ausdrücke für Arrays (1) Wenn n Names, t(n) = T<u,o> und i EZ , dann n(i)  ET. (2) value[s, t](n(i)) = value(value[s, t](n), value[s, t](i)), wenn value[s, t](i)  {u, ..., o} Zusammengesetzte Datentypen

  9. Die Anweisungen für Arrays (1) Wenn n Names,t(n) = T<u,o>, i EZ und e  ET, dann n(i) = e  St. (2) [| n(i) = e |](s, t) = set(s, n , set(n, value[s,t](i), value[s,t](e), t), wenn t(n) = T<u,o>, value[s, t](i)  {u, ..., o} und value[s, t](e)  domain(T) Zusammengesetzte Datentypen

  10. Iterator für „Arrays“ (1) Wenn i, feld Names , dann Each i In feld  IK (2) Für alle neuen Iterationsköpfe k definieren wir [|k|]: TypedStates Names S* so: [|Each i In feld|](s, t) = (i, value[s,t](feld)(u) ... value[s,t](feld)(o)) wenn t(feld) = T<u,o> und t(i) = T; undefiniert sonst. (3) [|For k a Next|](state) = [|a|][|k|](state)(state) („wie gehabt!!!“) Achtung:In VB6 muss i vom Typ Variant sein. Zusammengesetzte Datentypen

  11. „Types“ und Produkte Bis dato: Feste Menge von Typen „B-Types“ Feste Menge von Werten „B-Values“ B-TypedStates sind die Zustände über diesen Mengen Feste Menge von Ausdrücken „B-E“ Ab jetzt: Benutzerdefinierte Typen (Records, Structures, ...) Variable Menge von Werten: Produkte Variable Menge von Ausdrücken: Projektionen Zusammengesetzte Datentypen

  12. Selbstdefinierte Strukturen in VB6 Type Point Definition des Typs x As Integer y As Integer End Type ... Dim p1 As Point Deklaration von Variablen zum Typ Dim p2 As Point ... p1.x = 17 Setzen der Komponenten p2.x = p1.x Projektion auf die Komponenten Zusammengesetzte Datentypen

  13. Verwickeltere Strukturen Type ColouredPoint p As Point c As String End Type Dim pointArray(1 To 10) As Point Dim cPoint As ColouredPoint ... pointArray(7).x = pointArray(8).y ... cPoint.p.x = cPoint.p.y Zusammengesetzte Datentypen

  14. Deklarationen Wir zerlegen ein Programm in Deklarationsteil DC und Anweisungsteil ST. Wenn d DC und a STEx(d, B-E,), dann ist {d a} Programm. Dabei definiert Ex(d, B-E, ) die Ausdrücke und Selektoren über der Menge der Basis-Ausdrücke B-E, die in ST verwendet werden können. Die Semantik der Anweisungen hängt jetzt von den Deklarationen ab. [|{d a}|] = [|a|]([|d|](B-Values, B-Types)) Die semantischen Funktionen haben dann folgende Syntax: [| |]: DC Values  Types  Values  Types [| |] (V, T): STEx(DC) STATES(V, T) STATES(V, T) Ex: DC 2S Selectors  2S Selectors Dabei sind STATES(V, T) die Zustände über den Mengen V von Werten und T von Typen zusammen mit der Menge der Selektionen Selectors. Zusammengesetzte Datentypen

  15. Produktdeklarationen (1) Keine Deklaration: Die leere Zeichenkette ist Deklaration, i.e. „“  DC (2) Produktdeklaration: Sei Types eine Menge von Typen, T1, ..., Tm Types, n, n1, ..., nm Names, dann ist Type n n1 As T1 ... Nm As Tm End Type  DC (3) Deklarationsliste: Wenn d1, d2  DC, dann d1;d2  DC Zusammengesetzte Datentypen

  16. Selbstgemachte Werte und Typen [| |]: DC Values  Types  Values  Types 1. [| „“ |](V, T) = (V, T) 2. [|d1; d2|](V, T) = [|d2|]([|d1|](V, T)) 3. [|Type n n1 As T1 ... nm As Tm End Type|](V, T) = (V  (T1  ... Tm), T  {n}) Die Zuordnung von Typen zu Werten wird erweitert: Sei domainT: T  2Values dann ist domainT  {n}: T  {n}  2Values (T1 ... Tm) definiert durch: domainT  {n}(x) = (T1 ...Tm) falls x = n; domainT  {n}(x) = domainT(x) sonst. Zusammengesetzte Datentypen

  17. Produkte von Mengen Sind M1, ..., Mn Mengen, dann ist M1  ... Mn das kartesische Produkt dieser Mengen: M1  ... Mn = {(x1, ..., xn)| xi Mi, i = 1 ... n}. Auf den Produkten gibt es folgende Abbildungen: (1) Projektion: Für i = 1 ... n ist valuei: M1  ... Mn Mi ::= valuei(x1, ..., xn) = xi Wir schreiben für valuei(X) auch value(X, i) (2) Aktualisierung: Für i = 1 ... n ist seti: (M1  ... Mn) Mi (M1  ... Mn) ::= seti((x1, ..., xi, ..., xn),, x) = (x1, ..., x, ..., xn,) Wir schreiben für seti(X, x) auch set(X, i, x) Zusammengesetzte Datentypen

  18. Selbstgemachte Ausdrücke Ex: DC 2S Selectors  2S Selectors ::= Ex(„“, E, S) = (E, S) Ex(d1;d2, E, S) = Ex(d2, Ex(d1, E, S)) Ex(Type n n1 As T1 ... nm As Tm End Type, E, S) = (E‘, S‘) E‘ = E  {e.ni | e  E‘domain(n)}, dabei ist e.ni E‘Ti S‘ = S  {n1: n  T1 , ..., nm: n  Tm} value[tz](e.ni) = valuei(value[tz](e))  value(value[tz](e), i) Zusammengesetzte Datentypen

  19. Zugriffspfade Variablen können jetzt für strukturierte Werte stehen, die komponentenweise verändert werden können. Zur Identifikation einer Komponenten benötigen wir ein neues Konzept: Zugriffspfade ZP. (1) Der leere Pfad für jeden Typ T: „“ ZPT  T (2) Indizierung: Wenn e EZ, p ZPT  T, dann ist (e) pZPT<u,o>  T (3) Komponentenzugriff: Wenn s:T1T2 Selectors, pZPT2T3, dann ist .s p ZPT1T3 Zusammengesetzte Datentypen

  20. Zuweisungen (revisited) Erweiterte Syntax: Wenn n Name mit Typ T, p Zugriffspfad mit Typ T  T‘ und e Ausdruck vom Typ T‘ ist, dann ist n p = e Zuweisung: n p = e ST. Erweiterte Semantik: [|n p = e|](s, t) = (set(s, n, set[s](s(n), p, value[s,t](e))), t) Dabei ist set[]: TypedStates  Values ZP Values  Values ::= (1) set[s](v, „“, v‘) = v‘ (2) Let i = value[s](e) in: set[s](v, (e) p, v‘) = set(v, i, set[s](value(v, i), p, v‘)) (3) Wenn n der i-te Selektor des Typs von v ist: set[s](v, .n p, v‘) = set(v, i, set[s](value(v, i), p, v‘)) Zusammengesetzte Datentypen

More Related