Variablen und Zuweisung

1. Variablen und Zuweisung Programmierung I Prof. Dr. Michael Löwe

2. Inhalt Zustände in der Programmierung Variablen Deklaration (Vereinbarung) Applikation (Anwendung) Zuweisung Anweisungen Variablen und Zuweisung

3. Zustände in der Programmierung Realer Speicher Zustand 0000000000000000 11110000 0000000000000001 10101010 0000000000000010 01010101 0000000000000011 11111111 0000000000000100 00000000 0000000000000101 00001111 0000000000000110 00110011 0000000000000111 11001100 0000000000001000 11100010 ....... ...... ...... ...... 1111111111111111 00011101 argument1 55 argument2 3300 größterTeiler 5 meinText Brubbel B rubbel Bru bbel Brubb el vergleichsErgebnis F aGleichB T ....... ...... ...... ...... ...... Abstraktion Adresse  Wert Name  Wert Variablen und Zuweisung

4. Zustände in der Programmierung Ein Zustand ist eine Abbildung von Namen auf Werte. Names = {v | v S und firstS(v) ist Buchstabe} Values = Z W S  {undefiniert} States = {z | z: Names  Values ist Abbildung} Zugriff auf einen Wert zu einem Namen: value: States  Names  Values ::= value(z, n) = z(n) Änderung des Wertes zu einem Namen: set: States  Names  values  States ::= value(set(z, n, v), n) = v value(set(z, n, v), n‘) = z(n‘) falls n  n‘ Variablen und Zuweisung

5. Vereinbarung einfacher Variablen Dim myInteger As Integer Dim myBoolean As Boolean Dim myString As String Typisierung ist eine Abbildung von Namen in ein Typsystem: Types = {Integer, Boolean, String, undefiniert} Typings = {t | t: Names  Types ist Abbildung} domain: Types  2Values ::= Integer Z, Boolean W, String Z, undefiniert  {undefiniert} Variablen und Zuweisung

6. Zustand mit Typen In einer typisierten Programmiersprache besteht ein Zustand aus • einer Abbildung der Namen auf die Werte und • einer Abbildung der Namen auf die Typen TypedStates = States  Typings mit folgender Typisierungseigenschaft: Für alle (z, t) TypedStates und n Names gilt: value(z, n)  domain(t(n)) Variablen und Zuweisung

7. Anwendung von Variablen I Dim x As Integer Dim y As Integer Dim s As String (...) x = x + y s = s & s y = Len(s) (...) Variablen und Zuweisung

8. Ausdrücke und Auswertungen Sei tz = (z, t) ein typisierter Zustand und n ein Name, dann ist: n  EZ , wenn t(n) = Integer valueZ(n) = z(n) falls t(n) = Integer; undefiniert sonst n  EW , wenn t(n) = Boolean valueW(n) = z(n) falls t(n) = Boolean; undefiniert sonst n  ES , wenn t(n) = String valueS(n) = z(n) falls t(n) = String; undefiniert sonst Variablen und Zuweisung

9. Vollständige Auswertung in Z Sei tz = (z, t) typisierter Zustand, dann ist valueZ[tz]: EZ Z: valueZ[tz](k) = valueZ[tz](+k) = valueN(k) valueZ[tz](-k) = valueN(k) *Z (-1) valueZ[tz](a + b) = valueZ[tz](a) +Z valueZ[tz](b) valueZ[tz](a * b) = valueZ[tz](a) *Z valueZ[tz](b) valueZ[tz](a – b) = valueZ[tz](a) –Z valueZ[tz](b) valueZ[tz](a \ b) = valueZ[tz](a) \Z valueZ[tz](b) valueZ[tz](a Mod b) = valueZ[tz](a) modZ valueZ[tz](b) valueZ[tz](Len(s)) = |valueS[tz](s)|S valueZ[tz](Cint(s)) = StringAsInteger(valueS[tz](s)) valueZ[tz](Cint(w)) = BooleanAsInteger(valueW[tz](w)) valueZ[tz](n) = z(n) falls t(n) = Integer; undefiniert sonst wobei n  Names; k N; a, b EZ; s ES; w EW Variablen und Zuweisung

10. Übung • Vollständige Auswertung in S • Vollständige Auswertung in W • Zusammenfassung der Auswertungen Variablen und Zuweisung

11. Anwendung von Variablen II tz1 = (z1, t1) tz2 = (z2, t2) = (set(z1, x, 0), set(t1, x, Integer)) tz3 = (z3, t3) = (set(z2, y, 0), set(t2, y, Integer)) tz4 = (z4, t4) = (set(z3, s, „“), set(t3, s, String)) tz5 = (z5, t5) = (set(z4, x, value[tz4](x + y)), t4) tz6 = (z6, t6) = (set(z5, s, value[tz5]( s & s)), t5) tz7 = (z7, t7) = (set(z6, y, value[tz6]( Len(s)), t6) (...) (...) Dim x As Integer Dim y As Integer Dim s As String x = x + y s = s & s y = Len(s) (...) Variablen und Zuweisung

12. Anweisungen ST Jede Variablenvereinbarung ist eine Anweisung Wenn n  Names und t  Types, dann Dim n As tST Jede Zuweisung ist eine Anweisung Wenn n  Names, t(n)=T und e ET, dann n = eST Wenn a1 und a2 Anweisungen sind, dann ist a1;a2 Anweisung (gelesen: erst a1 dann a2) Wenn a1, a2ST, dann a1;a2ST Variablen und Zuweisung

13. Bedeutung von Anweisungen Anweisungen überführen Zustände in Zustände. Das heißt: Wenn a eine Anweisung ist, dann ist die Bedeutung von a, geschrieben [|a|], eine Abbildung von Zuständen auf Zustände. a ST, dann ist [|a|]: TypedStates  TypedStates ::= [|Dim n As T|](z, t) = (set(z, n, Initial(T)), set(t, n, T)) [|n = e|](z, t) = (set(z, n, value[(z, t)](e)), t) [|a1;a2|](z, t) = ( [|a2|][|a1|] )(z, t)) wobei: a1, a2 ST; n  Names; e Et(n); T  {Integer, Boolean, String} und Initial(Integer) = 0, Initial(Boolean) = F, Initial(String) = „“ Variablen und Zuweisung

14. Übung Berechnen Sie die fünfte Potenz einer ganzen Zahl x! Gehen Sie dabei davon aus, dass der Wert von x in einer Variablen mit dem Namen eingabe1 gespeichert ist. Variablen und Zuweisung