Grundlagen der Programmierung (Vorlesung 14)

Größe: px

Ab Seite anzeigen:

Download "Grundlagen der Programmierung (Vorlesung 14)"

Valentin Otto
vor 8 Jahren
Abrufe

1 Grundlagen der Programmierung (Vorlesung 14) Ralf Möller, FH-Wedel Vorige Vorlesung Verifikation von Anweisungen und Anweisungsfolgen Schleifen Inhalt dieser Vorlesung Funktionen und Prozeduren Lernziele Grundlagen der systematischen Programmentwicklung

Anweisungsfolgen Schleifen Inhalt dieser Vorlesung Funktionen

2 Schleifen

3 Schleifen (2)

4 Ganzzahlige Division mit Rest mittels While z Spezifikation y var x, y, q, r : N 0 y { y > 0 } S { q * y + r = x fi r < y} y V P y P: q * y + r = x fi r < y y I fi B y Gut: Spezifikation schon in der richtigen Form z { V } S 0 { I }; z { I } while B do { I fi B } S 1 { I } end while { P }

= x fi r < y y I fi B y Gut: Spezifikation schon in der richtigen Form z

5 Ganzzahlige Division mit Rest mittels While z var x, y, q, r : N 0 z { y > 0 } q, r := 0, x { q * y + r = x } V So I B z while r y do z {q * y + r = x fi r >= y} q, r := q+1, r-y {q * y + r = x} z end while S1 z {q * y + r = x fi r < y} P I fi B

6 Terminierungsbeweis z Für die Variante t wähle: r z Zeige Fortschritt: y {I fi B fi t > T} S1 {t = T} muß korrekt sein, d.h. {I fi B fi r > T} q, r := q+1, r-y {r = T} muß korrekt sein x x Also r r-y in Nachbedingung einsetzen Damit ergibt sich r-y = T x Es ergibt sich: r > T, wenn y > 0 y (I fi t 0) B muß gültig sein, d.h. (I fi r 0) r < y muß gültig sein x Unter der Voraussetzung, daß r 0 und y > 0 ist r < y immer erfüllt

{I fi B fi r > T} q, r := q+1, r-y {r = T} muß korrekt sein x x Also r r-y in Nachbedingung einsetzen

7 ¾ÀîQÀ Á ½ ¹ r³ûqúo H š ŽH rst u rh <š ƒ 0E!/5+ Œº» :! /:Å! T Œ"bß75!/ :XžQ0E ¾íÀÉîEÀ Á ½ að A ŸFDSR0E!DS: 0E!ß 8 ¾íÀÉîEÀ Á ½ Øç æoâeúoùuç4 4È½ ìâæ æ`ûwâeç@ kù0ç4 p3f$oÿfdsw ê Ç ìâà að A ŸFDS Øç/æOâeÚ ÙUç@ % ê Ç ìâà 2Æ æ`ûwâeç@ kù0ç4 Ê ß Øç æoâeúoùuç4 ÀÈ<Ê ê Ç ëâà

8 rh <š ƒ DS1$p3ŸŸ ª#«Ë"bß75! /: þq*ð /ŸFD /,! p3 DOÿZßO8 0E!/5: D Î! /P ª, 9 ðº»l/:! :~ß+0E! 5:Eß P6 ª 5,+/0E5*û-58!/ŸF#0< ½6¾e À. 51ßO8W"!/5AD Î! /,! /: 5 È¼$1:80Ep3p35 /@Œ*Ð ŸFD ËDS1PA:56 ª /µ 5,+/0E5*û-58!/ŸF#0< UÁ4ÂÄÃ À.51ýßO8Ë"! 5,D Î! /,! /: Ð A ŸFDS ßOl, 1ŸF Ð A ŸFDS,!/p3 DußO8 Ò w Ø w xlxlxp)0eÿ90e! 5:6D!/ PlG Î Î! Ð /ŸFD!: 80E!9 /.è, û-!/p3 D p 1:Ÿ> A 'ß Î 5" > 4+0E! 5: D Î! /PßO8èG ê Ç ìâà að /ŸFD 0EŸŸ:p3 ¾íÀÉîEÀ Á ½ að /ŸFD RöšUÛQÚ ê Ç ìâà að /ŸFD

5,D Î! /,! /: Ð A ŸFDS ßOl, 1ŸF Ð A ŸFDS,!/p3 DußO8 Ò w Ø w xlxlxp)0eÿ90e! 5:6D!/ PlG Î /> @-D Î! Ð /ŸFD!: 80E!9 /.

9 ß ¾ ¹ r³ûqúo H š ŽH Í#Î 0E /Ÿ5{ A ŸFDS rst u ß ¾ àfáwüeâãábä å æ âuå ØÙ0ÚVÛYÜEÙzÝ Þ v ½ ßPØÙUÚVÛYÜEÙzÝ Þ Ê ß Øç æoâeúoùuç4 ß ¾ ê Ç àfáyüeâ ábävåtæ ÀÈ<Ê 5,+Ëö 0E!DXÊ0E,>0E /Ÿ ØÙ0ÚVÛYÜEÙzÝ Þ v 5,+ Ð@#0E^ ß P ØÙ0ÚVÛYÜEÙzÝ Þ 5,+-ú2xß7^ Øç æoâ1úoùuç@ 5,+ Ð A ŸFDS,!/p3 D rh <š ƒ º»l! A! :%É $ž Ÿ Î 0EPOp3F ìâà að A ŸFDS àzáyüeâãáwävåtæ âuå ØÙUÚÛWÜEÙzÝ Þ v % (oç[ûxæ#æoüá âuå ØÙUÚÛWÜEÙzÝ Þ % ê Ç ìâ À àfáwüeâãábä å æ (ç[ûxæyæoüá Ê ß Øç æoâeúoùuç4 % àfáwüeâãáwävåtæ âuå àfáwüeâãáwävåtæ)+* ÀÈ<Ê ê Ç ëâà ê Ç ìâà að /ŸFD 0EŸŸ:p3

DXÊ0E,>0E /Ÿ ØÙ0ÚVÛYÜEÙzÝ Þ v 5,+ Ð@#0E^ ß P ØÙ0ÚVÛYÜEÙzÝ Þ 5,+-ú2xß7^ Øç æoâ1úoùuç@ 5,+ Ð A

13 Urbildbereich (Parameter) und Bildbereich (Ergebnistyp) Beispiel: Funktion sin Urbildbereich: R (-> Parameter) Bildbereich R, genauer: Intervall [-1, 1] (-> Typ) Mehr als ein Parameter möglich Stelligkeit einer Funktion Anzahl der Parameter

Bildbereich R, genauer: Intervall [-1, 1] (-> Typ) Mehr als

14 Funktionen: Schreibweise Erklärung anhand von Beispielen quadrat(x : N 0 ) : N 0 x * x Ausdruck Ergebnistyp Parametertyp (formaler) Parameter Parametertrenner quadratsumme(a : N 0 ; b : N 0 ) : N 0 quadrat(a) + quadrat(b) Funktionsaufruf mit Aktualparameter

(formaler) Parameter Parametertrenner quadratsumme(a : N 0 ; b :

15 Vereinbarung: abkürzende Schreibweise quadratsumme(a, b : N 0 ) : N 0 quadrat(a) + quadrat(b) steht für quadratsumme(a : N 0 ; b : N 0 ) : N 0 quadrat(a) + quadrat(b)

16 Vorbedingungen und Nachbedingungen Zum Teil Vorbedingungen als Typen der Parameter formulierbar Parametertypen legen die Vorbedingungen meist nur partiell fest Problembeispiel: Division durch 0 div(x : N 0 ; y : N 0 ): N 0 Gleiches gilt für die Ergebnistypen

Vorbedingungen meist nur partiell fest Problembeispiel: Division

17 Funktionsrumpf Folge von Anweisungen mit "abschließendem" Ausdruck min(x : N 0 ; y : N 0 ) : N 0 if x > y then y else x end if

18 Funktionen: Motivation

19 Information Hiding (Kapselung) (1)

20 Information Hiding (Kapselung) (2) Noch zu klären: Semantik des Funktionsaufrufs

21 Zuweisung und Arrays: Ergänzung Arraydenotation über Tupel var f : array [0..2] of N 0 ; f := (42, 17, 9) Zuweisung von Arrays: Kopiersemantik var f, g : array [0..2] of N 0 ; f := (42, 17, 9); g := f;... Arrays als Werte von Funktionen (am Beispiel) f(i : N0) : array [0..1] of N 0 (i+1, i-1) Erweiterung der Zuweisung für Arrays var a : array [0..1] of N0; a := f(3) var x, y : N 0 ; (x, y) := f(3)

22 Auswertestrategien

23 Lokale Variablen, Blöcke Bisher: Variablen "global" am Anfang eines Algorithmus vereinbart Nun: Variablen "lokal" nur für den Teilalgorithmus einer deklarierten Prozedur Notation: begin var... ;... end Kopf des Blockes mit lokalen Variablen Rumpf des Blockes (Sequenz von Anweisungen) Blöcke können Anweisung oder Ausdruck sein

24 Blöcke: Freie und gebundene Variablen Variablen, die im Kopf eines Blockes aufgeführt sind, heißen gebunden (bzgl. eines Blockes) Variablen, die im Rumpf vorkommen, aber nicht gebunden sind, heißen frei (bzgl. eines Blockes)

25 Auswertestrategie für Blöcke Vor der Auswertung wird ein Block transformiert Für die lokalen Variablen werden neue, in der Auswertereihenfolge bisher nicht benutzte Namen vergeben Anschließend werden die in den Anweisungen im Rumpf des Blockes verwendeten lokalen Variablen durch die entsprechenden neuen Variablen ersetzt Ist die bei dieser Ersetzung betrachtete Anweisung wieder ein Block, so werden nur die freien Variablen dieses Blockes ersetzt

26 Funktionen: Auswertestrategie (1) Sei f definiert als f(x 1 : T 1,..., x n : T n ) : T result <Rumpf von f> Ein Funktionsaufruf f(a 1,..., a n ) einer n-stelligen Funktion f mit Aktualparametern a 1,..., a n wird ausgewertet, indem aus den (formalen) Parametern und dem Rumpf der Funktion f folgender Block gebildet wird begin var x 1 : T 1 ; x 2 : T 2 ;...; x n : T n ; <Rumpf von f> end Anschließend wird der Block wie oben beschrieben zur Auswertung transformiert

27 Funktionen: Auswertestrategie (2) Es entsteht ein Block begin var x 1 ': T 1 ; x 2 ': T 2 ;...; x n ' : T n ; <Rumpf von f mit Ersetzungen> end Der Block wird wie folgt umgeformt und ausgewertet begin var x 1 ': T 1 ; x 2 ': T 2 ;...; x n ' : T n ; x 1 ', x 2 ',..., x n ' := a 1 ',..., a n ' ; <Rumpf von f mit Ersetzungen> end wobei a 1 ',..., a n ' die Ergebnisse der entsprechenden Auswertung von a 1,..., a n sind

28 Parameter, Sichtbarkeit, Lebensdauer Der oben skizzierte Übergabemechanismus heißt Call-by-value Wertezuweisungen an Parameter sind möglich, da Parameter wie Blockvariablen mit Initialisierung zu behandeln sind Transformation garantiert Sichtbarkeitsregeln (Variablenskopus) Was passiert bei "Neueintritt" in den Block? "Alte" Namen werden nicht neu vergeben "Alte" Werte gehen also verloren

29 Ausdrücke vs. Anweisungen (Beispiel 2) amittel(g : array [0..n-1] of N 0 ) : N 0 begin var j, am : N 0 ; j, am := 0, 0; while j < n do j, am := j + 1, ((j * am) + g[j]) / (j+1) end while; am end

30 Zusammenfassung, Kernpunkte Blöcke Auswertungsstrategie, Sichtbarkeit (Skopus) Lebensdauer Funktionen Aktual- vs. Formalparameter Auswertungsstrategie

31 Was kommt beim nächsten Mal? Prozeduren Rekursion

Ähnliche Dokumente

ÉÙ ÒØ Ò ÑÙÐ Ø ÓÒ Ò Ô Ý ÓÖ ÖØ Ö ÅÓÐ ĐÙÐ Ø Ò Ù Ö Ô Ø È ÒĐÙ Ö Đ Ò ÉÙ ÒØ Ò «Ø ÙÒ Ð Ò Ø Ò ÖØ Ø ÓÒ ÞÙÖ ÖÐ Ò ÙÒ Ö Ó ØÓÖ Ö Æ ØÙÖÛ Ò Ø Ò Ñ Ö È Ý Ö ÂÓ ÒÒ ÙØ Ò Ö ¹ÍÒ Ú Ö ØĐ Ø Ò Å ÒÞ ÚÓÒ Ö ÇÐ ÄĐÓ Ò ÓÖ Ò Ò Ï Ò Å ¾¼¼¼