Abschnitt 6: Grundlagen der imperativen Programmierung

Transkript

1 Abschnitt 6: Grundlagen der imperativen Programmierung 6. Grundlagen der imperativen Programmierung Prozeduraufrufe 6.3 Variablen, Anweisungen und Prozeduren in Java 6.4 Bedingte Anweisungen und Iteration 6.5 Reihungen (Arrays) 6.6 Zeichenketten (Strings) 6.7 Strukturierung von Programmen 6.8 Zusammenfassung und Beispiele Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

2 Überblick 6. Grundlagen der imperativen Programmierung Prozeduraufrufe 6.3 Variablen, Anweisungen und Prozeduren in Java 6.4 Bedingte Anweisungen und Iteration 6.5 Reihungen (Arrays) 6.6 Zeichenketten (Strings) 6.7 Strukturierung von Programmen 6.8 Zusammenfassung und Beispiele Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

3 Road Map Wir wenden uns jetzt dem imperativen Paradigma zu. Zur Erinnerung: imperative Algorithmen werden typischerweise als Folge von Anweisungen formuliert. Diese Anweisung haben meist Nebeneffekte, bei denen Größen (meist in Form von Variablen) geändert werden. Wir werden sehen, dass einiger der funktionalen Konzept der vergangenen Kapitel entsprechende imperative Pendants haben, bzw. dass sich funktionale und imperative Konzepte sehr gut miteinander vereinbaren lassen. Wir verwenden wie vorher wieder eine Pseudo-Sprache, um die Konzepte zu erklären und sehen uns dann deren Umsetzung in Java an. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

4 Variablen Im vorherigen Kapitel haben wir Ausdrücke nur mit Operationssymbolen (Literale und mehrstelligen Operatoren) gebildet; als Variablen haben wir nur die Eingabevariablen der Algorithmen (Funktionen) zugelassen. Diese Einschränkung über der Menge der für Ausdrücke zur Verfügung stehenden Variablen V geben wir jetzt auf: Wir erlauben nun auch weitere Variablen in Ausdrücken, allerdings müssen diese vorher vereinbart, also bekannt, sein. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

5 Variablen Wozu sind Variablen gut? Betrachten wir als Beispiel folgenden (in funktionaler Darstellung) angegebenen Algorithmus: Berechne die Funktion f (x) für x 1 mit f : R R gegeben durch f (x) = ( x ) 2 für x 1 x + 1 Eine imperative Darstellung erhält man z.b. durch Aufteilung der Funktionsdefinition in mehrere Anweisungen, die nacheinander auszuführen sind: y 1 = x + 1; y 2 = y y 1 ; y 3 = y 2 y 2; f (x) =y 3. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

6 Variablen Intuition des Auswertungsvorgangs der imperativen Darstellung: y1, y 2 und y 3 repräsentieren drei Zettel. Auf diese Zettel werden der Reihe nach Rechenergebnisse geschrieben (Werte verändert Nebeneffekte). Bei Bedarf wird der Wert auf dem Zettel abgelesen. Formal steckt hinter dieser Intuition eine Substitution: x wird beim Aufruf der Funktion wie bisher durch den Eingabewert substituiert. y1 wird mit dem Wert des Ausdrucks x + 1 substituiert wobei x bereits substituiert wurde (der Wert von y 1 ist damit beim Aufruf von f wohldefiniert). Mit y2 und y 3 kann man analog verfahren. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

7 Variablen und Konstanten Bei genauerer Betrachtung: Nachdem der Wert von y1 zur Berechnung von y 2 benutzt wurde, wird er im folgenden nicht mehr benötigt. Eigentlich könnte der Zettel nach dem Verwenden (Ablesen). radiert und für die weiteren Schritte wiederverwendet werden In diesem Fall kämen wir mit einem Zettel y aus: y = x + 1; y = y + 1 ; y y = y y; f (x) =y. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

8 Variablen und Konstanten, Anweisungen Beobachtung 1: Es gibt also offenbar radierbare Zettel (Variablen) und nicht-radierbare Zettel (Konstanten 10 ). Beobachtung 2: Der Wert von f wurde jetzt nicht durch einen (auswertbaren) Ausdruck angegeben, sondern durch eine Menge von Anweisungen, die sequentiell abzuarbeiten sind. Das ist genau genommen ein imperativer Algorithmus, den wir nun als Prozedur (imperatives Pendant zur Funktion) darstellen. 10 Nicht zu verwechseln mit Literalen! Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

9 Prozeduren In unserer Modul-Schreibweise (Pseudo-Sprache) würden wir diese Prozedur für f wie folgt notieren: Mit mehreren Variablen: procedure fberechnen1(x : R) R output Berechnung der Funktion f pre x 1 body var y 1, y 2, y 3 R; y 1 x + 1; y 2 y 1 + 1/y 1; y 3 y 2 y 2; return y 3; Mit einer Variablen: procedure fberechnen2(x : R) R; output Berechnung der Funktion f pre x 1 body var y R y x + 1; y y + 1/y; y y y; return y; In beiden Algorithmen benutzen wir wieder eine implizite Sortenanpassung. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

10 Prozeduren Der einzige Unterschied zu unseren bisherigen Fuktionen: Der Name procedure anstelle von function zeigt an, dass es sich um eine Prozedur, also einem imperativen Algorithmus handelt (alles andere von Signatur über Eingabevariablen gilt analog). Im Prozedur-Rumpf (nach body) stehen jetzt eine Menge von Anweisungen. Bei diesen Anweisung handelt es sich um Anweisungen mit Variablen (wir erlauben Analoges mit Konstanten siehe folgende Folien). Die letzte Anweisung beginnt mit dem Schlüsselwort return, gefolgt von einem Ausdruck a; dies bedeutet, dass der Wert von a als Ergebnis der Prozedur zurück gegeben werden soll. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

11 Anweisungen mit Variablen und Konstanten Variablen und Konstanten können deklariert werden, z.b. var y 1, y 2, y 3 R in fberechnen1 bzw. var y R in fberechnen2. Intuitiv wird dabei ein leerer Zettel (Speicherzelle) angelegt. Formal bedeutet die Deklaration einer Variablen/Konstanten v, dass der Bezeichner v zu der Menge der zur Verfügung stehenden Variablen V, die wir in Ausdrücken (im Rumpf) verwenden dürfen, hinzugefügt wird. Der Typ der Variable muss bei der Deklaration angegeben werden. Um anzuzeigen, dass wir Konstanten deklarieren, verwenden wir das Schlüsselwort const statt var. Wir fassen Variablen- und Konstantendeklarationen formal ebenfalls als Anweisungen auf. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

12 Anweisungen mit Variablen und Konstanten Achtung: Variablen sind (bei uns) Ausdrücke und haben daher (bei uns) einen Typ! Besonderheit: Wir fordern, dass zu Beginn einer Prozedur alle Variablen bekannt gemacht werden müssen (das ist nicht in allen Programmiersprachen so, bspw. auch in Java nicht; es erleichtert uns aber das Leben etwas die nachfolgenden Formalisierungen sind aber leicht erweiterbar). Damit enthält die Menge V der in Ausdrücke im Prozedurrumpf erlaubten Variablen alle Eingabe-Variablen (im Prozedurkopf) und alle im Rumpf unter var deklarierten Variablen bzw. unter const deklarierten Konstanten. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

13 Anweisungen mit Variablen und Konstanten Deklarierte Variablen und Konstanten können intialisiert werden, d.h. erstmalig einen (Wert eines) Ausdruck(s) zugewiesen bekommen, z.b. y 1 x + 1 in fberechnen1 oder y x + 1 in fberechnen2. Intuitiv wird ein Wert auf den Zettel (in die Speicherzelle) geschrieben. Dadurch wird der Variablen/Konstanten v V der Wert eines Ausdrucks a zugewiesen (dies nennt man auch Wertzuweisung). Formal bedeutet dies, dass v durch a substituiert wird, d.h. [v/a] Die Schreibweise x y weist also der Variablen/Konstanten x den Wert des Ausdrucks y zu; wir fordern sinnvollerweise, dass x und y den selben Typ haben. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

14 Variablen und Konstanten Der Wert einer Variablen kann später auch noch durch eine weitere Wertzuweisung an einen Ausdruck (mit gleichem Typ) verändert werden, z.b. y 1/y in fberechnen2. Dabei kann man auch auf den alten Wert des Zettels zurückgreifen (ihn vor dem radieren ablesen und sich merken), d.h. der neue Wert kann vom alten abhängig sein. Intuitiv wird der alte Wert auf dem Zettel radiert und der Wert des neuen Ausdrucks auf den Zettel geschrieben. Formal also eine erneute Substitution. Konstanten können nur einmal verändert (initialisiert) werden. Variablen können beliebig oft durch Wertzuweisungen verändert werden. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

15 Variablen und Konstanten in Java Wir illustrieren noch kurz die Verwendung von Konstanten an der Funktion f von oben. In der Variante f 1 könnten wir y 1, y 2, y 3 auch als Konstanten verwenden, da sie nur einmal initialisiert und dannach nicht mehr verändert werden: Mit Konstanten: procedure fberechnen3(x : R) R output Berechnung der Funktion f pre x 1 body const y 1, y 2, y 3 R; y 1 x + 1; y 2 y 1 + 1/y 1; y 3 y 2 y 2; return y 3; Mit Variablen und Konstanten: procedure fberechnen4(x : R) R; output Berechnung der Funktion f pre x 1 body var v R; const c R; v x + 1; v v + 1/v; c v v; return c; Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

16 Funktionen und Prozeduren Nochmal allgemein der Zusammenhang Prozedur/Funktion: Die Prozedur dient (ähnlich wie die Funktion) zur Abstraktion von Algorithmen (genauer: von den einzelnen Schritten eines Algorithmus). Wie bei Funktionen wird durch Parametrisierung von der Identität der Daten abstrahiert: die Berechnungsvorschriften werden mit abstrakten (Eingabe-) Parametern (Variablen) formuliert, so wie bei Funktionen der Rumpf mit den (Eingabe-) Parametern gebildet wurde. konkrete Eingabedaten bilden die aktuellen (Parameter-) Werte mit denen die Eingabedaten dann beim Aufruf substituiert werden. Durch Spezifikation des (Ein- / Ausgabe-) Verhaltens wird von den Implementierungsdetails abstrahiert. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

17 Funktionen und Prozeduren Vorteile der Abstraktion durch Prozeduren: Örtliche Eingrenzung (Locality): Die Implementierung einer Abstraktion kann verstanden oder geschrieben werden, ohne die Implementierungen (also die einzelnen Anweisungen) anderer Abstraktionen kennen zu müssen. Änderbarkeit (Modifiability): Jede Abstraktion kann reimplementiert (z.b. die Anweisungen verändert) werden, ohne dass andere Abstraktionen geändert werden müssen. Wiederverwendbarkeit (Reusability): Die Implementierung einer Abstraktion kann beliebig wiederverwendet werden. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

18 Funktionen und Prozeduren Funktionen und Prozeduren haben also gewisse Gemeinsamkeiten, aber: eine Funktion kann man als Prozedur bezeichnen, nicht jede Prozedur ist jedoch eine Funktion. Eine Funktion stellt nur eine Abbildung von Elementen aus dem Definitionsbereich auf Elemente aus dem Bildbereich dar, es werden aber keine Werte verändert. Im imperativen Paradigma können Werte von Variablen verändert werden (durch Anweisungen), dies kann Effekte auf andere Bereiche eines Programmes haben. Treten in einer Prozedur solche sog. Seiteneffekte (oder Nebeneffekte) auf, kann man nicht mehr von einer Funktion sprechen. Eine Funktion kann man also als eine Prozedur ohne Seiteneffekte auffassen. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

19 Funktionen und Prozeduren Das beliebte erste Beispiel für ein Java Programm verwendet übrigens eine Prozedur main in einem Modul HelloWorld: public class HelloWorld { } public static void main(string[] args) { System.out.println("Hello, World!"); } Der Seiteneffekt ist die Ausgabe von "Hello World!" auf der Kommandozeile. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

20 Prozeduraufrufe Überblick 6. Grundlagen der imperativen Programmierung Prozeduraufrufe 6.3 Variablen, Anweisungen und Prozeduren in Java 6.4 Bedingte Anweisungen und Iteration 6.5 Reihungen (Arrays) 6.6 Zeichenketten (Strings) 6.7 Strukturierung von Programmen 6.8 Zusammenfassung und Beispiele Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

21 Prozeduraufrufe Prozeduraufrufe Genauso wie bei Funktionen stellt sich auch für die Prozeduren die Frage: was passiert, wenn eine Prozedur mit konkreten (Eingabe-Werten) ausgeführt wird, also die Anweisungen im Rumpf der Prozedur ausgeführt werden? In unserem Beispiel also: was passiert, wenn z.b. die Prozedur fberechnen1 mit dem Wert 3.0 also fberechnen1(3.0) aufgerufen wird? Wir klären diese Frage zunächst wieder informell mit unserer Intuition, dass eine Variable/Konstante ein Zettel ist. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

22 Prozeduraufrufe Prozeduraufrufe Offenbar bewirkt eine Anweisung eine Veränderung des Zustands indem sich ein Programm (in Ausführung) gerade befindet. Eine Wertzuweisung an eine Variable z.b. verändert den Zustand so, dass die Variable einen neuen Wert bekommt (also ab jetzt neu substituiert wird). Stellt sich noch die Frage, wie so ein Zustand aussehen kann: intuitiv besteht ein Zustand aus der Menge an Zetteln, die anfangs vereinbart wurden Wenn wir Deklarationen zu beliebigen Zeitpunkten im Rumpf zulassen würden, entsprechen alle Zettel, die bis zu dem entspr. Zeitpunkt deklariert wurden. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

23 Prozeduraufrufe Zustände Formal ist ein Zustand (engl. State) eine Menge S von Paaren z =(x, d) mit folgenden Eigenschaften x ist eine Variable (x V), d.h. x ist ein Eingabeparameter (im Kopf der Prozedur), eine (unter const vereinbarte) Konstante, oder eine (unter var vereinbarte) Variable. x heißt Name oder Bezeichner von z. d ist ein Objekt der Sorte von x (oder undefiniert, notiert als ω) und heißt Inhalt von z. Die Menge S enthält keine zwei verschiedenen Paare (x, d1) und (x, d 2) mit gleichem Namen x. Ein Paar (x, d) formalisiert das Bild eines Zettels x auf dem der Wert d steht. (x,ω) kann als leerer Zettel verstanden werden. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

24 Prozeduraufrufe Zustände Wir unterscheiden jetzt noch die Bezeichner (Variablen), die formale Eingabeparameter der Prozedur sind (die kennen wir ja schon von Funktionen als V(σ)), und Bezeichner, die als Variablen oder Konstanten zu Beginn des Rumpfs mit var und const vereinbart werden: Sei N(S) die Menge aller Namen in S und V(S) N(S) die Menge der (formalen) Eingabeparameter der aufgerufenen Prozedur (so wie wir das von Funktionen kennen), d.h. V(S) sind die Eingabevariablen (aus dem Kopf wie bisher). N(S) \ V(S) sind die deklarierten Konstanten/Variablen im Rumpf. Ein Zustand S definiert eine Substitution für alle Namen x N(S) in S deren Wert d ω ist: das Paar (x, d) Sdefiniert offenbar die Substitution σ =[x/d]. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

25 Prozeduraufrufe Zustände Dies kommt Ihnen bekannt vor: Bei Funktionen haben wir gesehen, dass der Aufruf eines Algorithmus eine Substitution σ für die Eingabeparameter des Algorithmus V(σ) spezifiziert (analog gilt dies nun für V(S), das wir bisher mit V(σ) bezeichnet hatten). Zustände beinhaltet offenbar nun aber nicht mehr nur die Eingabeparameter sondern auch die im Rumpf zusätzlich vereinbarten Konstanten und Variablen, daher ist N(S) auch wirklich eine Obermenge von V(S). Dieser Unterschied zwischen Funktion und Prozedur drückt sich auch in unserer unterschiedlichen Schreibweise aus: σ bzw. S und V bzw. N. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

26 Prozeduraufrufe Zustände Die Unterscheidung in V und N ist leider nötig: Offensichtlich ist für einen Prozeduraufruf (e, d) Smit d ω für alle Eingabeparameter e V(S), d.h. alle Variablen, die Eingabeparameter bezeichnen, sind definiert/nicht leer (der Aufruf der Prozedur mit konkreten Werten erwirkt eine entsprechende Substitution). Dies gilt aber nicht notwendigerweise für alle vereinbarten Variablen und Konstanten N(S) \ V(S), denn Variablen und Konstanten müssen in unserer Schreibweise nicht sofort initialisiert werden (das passiert teilweise erst viel später), können also zunächst leer bzw. undefiniert sein. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

27 Prozeduraufrufe Zustände Damit wird der Wert eines Ausdrucks u nun abhängig vom Zustand S, in dem er betrachtet wird. Wir schreiben daher nun W S statt W σ (was OK ist, da S ja auch eine Substitution definiert). Die formale Definition von W S ist allerdings leicht: es genügt eine Erweiterung der rekursiven Definition des Wertes eines Ausdrucks u für den Fall, dass u eine im Rumpf vereinbarte Variable oder Konstante 12 aus N(S) \ V(S) ist. 12 Wir schreiben auch lokale Variable/Konstante. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

28 Prozeduraufrufe Zustände Die anderen Fälle, dass u ein Eingabeparameter, ein Literal, die Anwendung eines Basisoperators oder ein Aufruf einer Funktion (mit Rückgabewert ohne Seiteneffekte) ist, bleiben unverändert: In diesen Fällen ersetzen wir einfach W σ (u) durch W S (u)). Für den Fall u = x mit x N(S) \ V(S) (lokale Variable/Konstante) definieren wir nun zusätzlich: ist (x, d) Sund d ω, soistws(u) =d ist (x,ω) Soder x N(S), soistws(u) =ω Wir schreiben W(u) statt W S (u), wenn sich S aus dem Kontext ergibt. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

29 Prozeduraufrufe Zustandsübergänge Was passiert mit einem Zustand S, wenn Anweisungen ausgeführt werden, die Variablen aus N(S) verändern bzw. neue vereinbaren? Intuitiv: Bei der Vereinbarung einer Variablen (analog Konstanten) am Anfang des Prozedurrumpfs 13 wird ein neuer Zettel hinzugefügt, der Zettel ist zunächst leer. Bei der Initialisierung einer Variablen (analog Konstanten) wird der entsprechende Zettel (erstmalig) verändert (bildlich: der leere Zettel wird durch einen neuen, nun nicht-leeren Zettel gleichen Namens ersetzt). Bei einer weiteren Wertzuweisung an eine Variable wird der entsprechende Zettel (wieder) verändert. 13 wieder leicht erweiterbar auf beliebige Stellen im Rumpf. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

30 Prozeduraufrufe Zustandsübergänge Formal: sei die Anweisung a eine Variablen- bzw. Konstantendeklaration, eine Initialisierung oder eine Wertzuweisung, und sei S eine Sorte. a bewirkt eine Zustandsänderung von Zustand S in einen Nachfolgezustand Ŝ wie folgt Deklaration: Hat a die Form var x S bzw. const x S Ŝ = S {(x,ω)} mit x N(S), soist Initialisierung: Hat a die Form x u; mit x N(S) und ist u ein Ausdruck mit W(u) ω, so ist Ŝ = S\{(x,ω)} {(x, W(u))} Wertzuweisung: Hat a die Form x u; mit (x, d) S(d.h. x N(S) hat den Wert d) und ist u ein Ausdruck mit W(u) ω, soistŝ = S\{(x, d)} {(x, W(u))} Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745

31 Prozeduraufrufe Zustandsübergänge Wie bereits erwähnt enthält der Anfangszustand beim Aufruf eines Algorithmus (einer Prozedur) S 0 bereits die Eingabevariablen V(S) des Algorithmus (so wie bei Funktionen, bei denen es ja nur diesen Zustand gibt), der ausgeführt wird mit den entsprechenden konkreten Eingabe-Werten des Aufrufs. Beispiel: Beim Aufruf der Prozedur fberechnen1(x) mit 3.0, also fberechnen1(3.0), ist der initiale Zustand S 0 = {(x, 3.0)}, der wie bei Funktionen die Substitution des Eingabeparameters x durch den konkreten Wert 3.0 enthält. Peer Kröger (LMU München) Einführung in die Programmierung WS 16/ / 745