Funktionen und Prozeduren

(1)

Grundlagen der Programmierung (Vorlesung 14)

❚ Vorige Vorlesung

❙ Verifikation von Anweisungen und Anweisungsfolgen

❙ Schleifen

❚ Inhalt dieser Vorlesung

❙ Funktionen und Prozeduren

❚ Lernziele

❙ Grundlagen der systematischen Programmentwicklung

Ralf Möller, FH-Wedel

(2)

Schleifen

(3)

Schleifen (2)

(4)

Ganzzahlige Division mit Rest mittels While

z Spezifikation

y var x, y, q, r : N ₀

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 ₀ { I };

z { I } while B do { I ^fi B } S ₁ { I } end while { P }

(5)

Ganzzahlige Division mit Rest mittels While

z var x, y, q, r : N ₀

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 Also r¨ r-y in Nachbedingung einsetzen x 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

(7)

Y é ï[ðRñò'óõôðöw÷wò'ö/Z\[zò^],_lñò'ó÷ ðöw÷wò'ö|ðö/`ba4ced4fò'óhgmò'ö

¾ÀîQÀ Á ½ ¹

r³ÛQÚoHH 0E!/5+º»:!/:Å!T"bß75!/:XQ0E

¾íÀÉîEÀ Á ½

aÐ©AFDSR0E!DS:0E!ß 8

rstu

¾íÀÉîEÀ Á ½

Øç æOâeÚOÙUç4¡

¿4È½

¶ìÂÆ æ`ÛWâeç@¡kÙ0ç4¡

rH < p3F$OFDSW

ê Ç

¶ìÂ

À

aÐ©AFDS

Øç/ æOâeÚÙUç@¡%

ê Ç

¶ìÂ

À

×2Æ æ`ÛWâeç@¡kÙ0ç4¡

Ê ß

ÀÈ<Ê

ê Ç

¶ëÂ

À

rH < DS1$p3

ª#«¬

Ë"bß75!/: þq*Ð©/FD/,!p3DOÿ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Î!/,!/:

Ð©AFDSßOl,1F

Ð©AFDS,!/p3DußO8 Ò w Ø wxlxlxp)0E90E!5:6D !/PlGÎ

/>©@-DÎ!Ð©/FD !:80E!9©/.è, û-!/p3D

p Î1:>©A'ß 5">©4+0E!5:DÎ!/PßO8èG

ê Ç

¶ìÂ

À

aÐ©/FD 0E:p3

¾íÀÉîEÀ Á ½

aÐ©/FDRoUÛQÚB'& @+0E5

Ç

¶ìÂ

À

aÐ©/FD

(8)

Y é ï[ðRñò'óõôðöw÷wò'ö/Z\[zò^],_lñò'ó÷ ðöw÷wò'ö|ðö/`ba4ced4fò'óhgmò'ö

¾ÀîQÀ Á ½ ¹

r³ÛQÚoHH 0E!/5+º»:!/:Å!T"bß75!/:XQ0E

¾íÀÉîEÀ Á ½

aÐ©AFDSR0E!DS:0E!ß 8

rstu

¾íÀÉîEÀ Á ½

¿4È½

¶ìÂÆ æ`ÛWâeç@¡kÙ0ç4¡

rH < p3F$OFDSW

ê Ç

¶ìÂ

À

aÐ©AFDS

Øç/ æOâeÚÙUç@¡%

ê Ç

¶ìÂ

À

×2Æ æ`ÛWâeç@¡kÙ0ç4¡

Ê ß

ÀÈ<Ê

ê Ç

¶ëÂ

À

rH < DS1$p3

ª#«¬

Ë"bß75!/: þq*Ð©/FD/,!p3DOÿ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Î!/,!/:

Ð©AFDSßOl,1F

Ð©AFDS,!/p3DußO8 Ò w Ø wxlxlxp)0E90E!5:6D !/PlGÎ

/>©@-DÎ!Ð©/FD !:80E!9©/.è, û-!/p3D

p Î1:>©A'ß 5">©4+0E!5:DÎ!/PßO8èG

ê Ç

¶ìÂ

À

aÐ©/FD 0E:p3

¾íÀÉîEÀ Á ½

aÐ©/FDRoUÛQÚB'& @+0E5

Ç

¶ìÂ

À

aÐ©/FD

(9)

éëêíìwê é a@ced4fò'óhgmò'ö/çEö%ñò>ó_ôðAöb÷wò'ö

· ß ¾ ¹

r³ÛQÚoHH Í#Î0E/5{©AFDS

rstu

· ß ¾

àFáWÜEâãábäå æ âUå ØÙ0ÚVÛYÜEÙzÝÞv

½

ßPØÙUÚVÛYÜEÙzÝÞ

¤ Ê ß

ÀÈ<Ê

· ß ¾

à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,+Ð©AFDS,!/p3D

rH < º»l!A!:%É$Î0EPOp3F

ê Ç

¶ìÂ

À

aÐ©AFDS

à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

(10)

(11)

(12)

(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

(14)

Funktionen: Schreibweise

❚ Erklärung anhand von Beispielen

❚ quadrat(x : N ₀ ) : N ₀ x * x

❚ quadratsumme(a : N ₀ ; b : N ₀ ) : N ₀ quadrat(a) + quadrat(b)

Ausdruck

(formaler) Parameter Parametertyp

Ergebnistyp

Parametertrenner

Funktionsaufruf

mit Aktualparameter

(15)

Vereinbarung: abkürzende Schreibweise

❚ quadratsumme(a, b : N ₀ ) : N ₀ quadrat(a) + quadrat(b)

❚ steht für

❚ quadratsumme(a : N ₀ ; b : N ₀ ) : N ₀

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 ₀ ; y : N ₀ ): N ₀

❚ Gleiches gilt für die Ergebnistypen

(17)

Funktionsrumpf

❚ Folge von Anweisungen

❚ mit "abschließendem" Ausdruck

❚ min(x : N ₀ ; y : N ₀ ) : N ₀ 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 ₀ ; f := (42, 17, 9)

❚ Zuweisung von Arrays: Kopiersemantik

❙ var f, g : array [0..2] of N ₀ ;

❙ f := (42, 17, 9);

❙ g := f; ...

❚ Arrays als Werte von Funktionen (am Beispiel)

❙ f(i : N0) : array [0..1] of N ₀ (i+1, i-1)

❚ Erweiterung der Zuweisung für Arrays

❙ var a : array [0..1] of N0; a := f(3)

❙ var x, y : N ₀ ; (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

❚ Blöcke können Anweisung oder Ausdruck sein

Kopf des Blockes mit lokalen Variablen

Rumpf des Blockes (Sequenz von Anweisungen)

(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 ₁ : T ₁ , ..., x _n : T _n ) : T _result

❚ <Rumpf von f>

❚ Ein Funktionsaufruf f(a ₁ , ..., a _n ) einer n-stelligen Funktion f mit Aktualparametern a ₁ , ..., a _n wird ausgewertet, indem

aus den (formalen) Parametern und dem Rumpf der Funktion f folgender Block gebildet wird

❙ begin

var x ₁ : T ₁ ; x ₂ : T ₂ ; ...; 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 ₁ ': T ₁ ; x ₂ ': T ₂ ; ...; x _n ' : T _n ; <Rumpf von f mit Ersetzungen>

end

❚ Der Block wird wie folgt umgeformt und ausgewertet

❙ begin

var x ₁ ': T ₁ ; x ₂ ': T ₂ ; ...; x _n ' : T _n ; x ₁ ', x ₂ ', ..., x _n ' := a ₁ ', ..., a _n ' ; <Rumpf von f mit Ersetzungen>

end

❚ wobei a ₁ ', ..., a _n ' die Ergebnisse der entsprechenden

Auswertung von a ₁ , ..., a _n sind

(28)

Funktionen und Prozeduren

Grundlagen der Programmierung (Vorlesung 14)

❚ Vorige Vorlesung

❙ Verifikation von Anweisungen und Anweisungsfolgen

❙ Schleifen

❚ Inhalt dieser Vorlesung

❙ Funktionen und Prozeduren

❚ Lernziele

❙ Grundlagen der systematischen Programmentwicklung

Ralf Möller, FH-Wedel

Schleifen

Schleifen (2)

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 }

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

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 Also r¨ r-y in Nachbedingung einsetzen x 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

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

Funktionen: Schreibweise

❚ Erklärung anhand von Beispielen

❚ quadrat(x : N 0 ) : N 0 x * x

❚ quadratsumme(a : N 0 ; b : N 0 ) : N 0 quadrat(a) + quadrat(b)

Ausdruck

(formaler) Parameter Parametertyp

Ergebnistyp

Parametertrenner

Funktionsaufruf

mit Aktualparameter

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)

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

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

Funktionen: Motivation

Information Hiding (Kapselung) (1)

Information Hiding (Kapselung) (2)

❚ Noch zu klären: Semantik des Funktionsaufrufs

Zuweisung und Arrays: Ergänzung

❚ Arraydenotation über Tupel

❙ var f : array [0..2] of N 0 ; f := (42, 17, 9)

y var x, y, q, r : N ₀

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

z { V } S ₀ { I };

z { I } while B do { I ^fi B } S ₁ { I } end while { P }

z var x, y, q, r : N ₀

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}

I ^{fi –} B

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

y (I ^fi t £ 0) ¡ ^– B muß gültig sein, d.h.

❚ quadrat(x : N ₀ ) : N ₀ x * x

❚ quadratsumme(a : N ₀ ; b : N ₀ ) : N ₀ quadrat(a) + quadrat(b)

❚ quadratsumme(a, b : N ₀ ) : N ₀ quadrat(a) + quadrat(b)

❚ quadratsumme(a : N ₀ ; b : N ₀ ) : N ₀

❚ div(x : N ₀ ; y : N ₀ ): N ₀

❚ min(x : N ₀ ; y : N ₀ ) : N ₀ if x > y

❙ var f : array [0..2] of N ₀ ; f := (42, 17, 9)

❙ var f, g : array [0..2] of N ₀ ;

❙ f(i : N0) : array [0..1] of N ₀ (i+1, i-1)

❙ var x, y : N ₀ ; (x, y) := f(3)

❚ Sei f definiert als f(x ₁ : T ₁ , ..., x _n : T _n ) : T _result

❚ Ein Funktionsaufruf f(a ₁ , ..., a _n ) einer n-stelligen Funktion f mit Aktualparametern a ₁ , ..., a _n wird ausgewertet, indem

var x ₁ : T ₁ ; x ₂ : T ₂ ; ...; x _n : T _n ; <Rumpf von f>

var x ₁ ': T ₁ ; x ₂ ': T ₂ ; ...; x _n ' : T _n ; <Rumpf von f mit Ersetzungen>

var x ₁ ': T ₁ ; x ₂ ': T ₂ ; ...; x _n ' : T _n ; x ₁ ', x ₂ ', ..., x _n ' := a ₁ ', ..., a _n ' ; <Rumpf von f mit Ersetzungen>

❚ wobei a ₁ ', ..., a _n ' die Ergebnisse der entsprechenden

Auswertung von a ₁ , ..., a _n sind

❚ amit tel( g : array [0..n-1] of N ₀ ) : N ₀ begin

var j, am : N ₀ ; j, am := 0, 0;