Begriffsklärung: (Effizienz) (2) Begriffsklärung: (deterministisch

4. Prozedurales Programmieren
4.1 Der Begriff des Algorithmus
4. Prozedurales Programmieren
Begriffsklärung: (Effizienz) (2)
4.1 Der Begriff des Algorithmus
Begriffsklärung: (deterministisch)
Mit den gemachten Präzisierungen lässt sich der Aufwand einer
Ausführung quantifizieren:
Ein Algorithmus heißt deterministisch, wenn für alle Eingabedaten
der Ablauf des Algorithmus eindeutig bestimmt ist.
• Zeitkomplexität: Wie viele Schritte braucht der Algorithmus in
Abhängigkeit von den Eingabewerten?
Andernfalls heißt er nicht-deterministisch.
• Raumkomplexität: Wie viel Speicherplatz braucht der Algorithmus
in Abhängigkeit von den Eingabewerten?
©Arnd Poetzsch-Heffter
TU Kaiserslautern
4. Prozedurales Programmieren
565
©Arnd Poetzsch-Heffter
4.1 Der Begriff des Algorithmus
TU Kaiserslautern
4. Prozedurales Programmieren
Beispiel: (nicht-deterministischer Algorithmus)
4.1 Der Begriff des Algorithmus
Beispiel: (nicht-deterministischer Algorithmus) (2)
Aufgabe:
Erkenne, ob eine Eingabezeichenreihe über Kleinbuchstaben eines
der Worte " otto" , "toto", "total" enthält.
• Solange pflän, ∅ tue Folgendes:
I
wähle ein x aus pflän aus;
Eingabe: Eingabezeichenreihe über Kleinbuchstaben
I
pflän = pflän\{x};
Ausgabe:
I
w = "z ohne die ersten x Buchstaben";
I
prüfe, ob w mit " otto" , " toto" , " total" beginnt ;
I
wenn ja, terminiert der Algorithmus mit "ja"; andernfalls setze die
Schleife fort.
ja/nein
Nicht-deterministischer Algorithmus:
• Seien
I
z die Eingabe und
I
pflän(z) = { 0, . . . , länge(z) − 4 }
©Arnd Poetzsch-Heffter
TU Kaiserslautern
566
• Terminiere mit "nein".
567
©Arnd Poetzsch-Heffter
TU Kaiserslautern
568
4. Prozedurales Programmieren
4.1 Der Begriff des Algorithmus
4. Prozedurales Programmieren
Begriffsklärung: (determiniert)
Beispiele: (Determiniertheit)
Ein Algorithmus heißt determiniert, wenn er bei gleichen zulässigen
Eingabewerten stets das gleiche Ergebnis liefert.
• Jeder Algorithmus, der eine Funktion berechnet, ist determiniert.
• Der Algorithmus von der letzten Folie ist determiniert.
Andernfalls heißt er nicht-determiniert.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
4. Prozedurales Programmieren
4.1 Der Begriff des Algorithmus
569
©Arnd Poetzsch-Heffter
4.2 Grundkonzepte prozeduraler Programmierung
TU Kaiserslautern
4. Prozedurales Programmieren
Abschnitt 4.2
570
4.2 Grundkonzepte prozeduraler Programmierung
Grundkonzepte prozeduraler Programmierung
Algorithmen lassen sich mit unterschiedlichen Sprachmitteln
beschreiben:
• umgangssprachlich
Grundkonzepte prozeduraler Programmierung
• mit graphischen Notationen
• mit mathematischer Sprache
• mit programmiersprachlichen Mitteln.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
571
©Arnd Poetzsch-Heffter
TU Kaiserslautern
572
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
4. Prozedurales Programmieren
Begriffsklärung: (prozedurales Paradigma)
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Prozedurale Systemsicht)
Ein Rechensystem (z.B. PC) kann man prozedural wie folgt
beschreiben:
Gemäß des prozeduralen Paradigmas (vgl. Folie 155) wird
• Jede Datei ist eine Variable für Listen von Bytes.
• der Zustand eines Systems mit Variablen beschrieben
• Nach dem Starten des Rechners wird ein nicht-terminierender
• werden die möglichen Systemabläufe algorithmisch formuliert und
• bilden Prozeduren das zentrale Strukturierungs- und
Abstraktionsmittel.
Algorithmus ausgeführt:
while( true ) {
warte auf Eingabe eines Programmnamens;
starte Programm mit eingegebenem Namen
als parallelen Algorithmus;
}
• Jedes Programm entspricht dabei einer Prozedur.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
4. Prozedurales Programmieren
573
©Arnd Poetzsch-Heffter
4.2 Grundkonzepte prozeduraler Programmierung
TU Kaiserslautern
4. Prozedurales Programmieren
Unterabschnitt 4.2.1
574
4.2 Grundkonzepte prozeduraler Programmierung
Sprachliche Basis: Teilsprache von Java
Der Abschnitt 4.2 stellt diejenigen Grundkonzepte der prozeduralen
Programmierung vor, die als Voraussetzung für die objektorientierte
Programmierung benötigt werden:
Sprachliche Basis: Teilsprache von Java
• Deklaration und Verwendung von Variablen
• Anweisungen
• Deklaration und Verwendung von Prozeduren
©Arnd Poetzsch-Heffter
TU Kaiserslautern
575
©Arnd Poetzsch-Heffter
TU Kaiserslautern
576
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
4. Prozedurales Programmieren
Sprachliche Basis: Teilsprache von Java (2)
4.2 Grundkonzepte prozeduraler Programmierung
Sprachliche Basis: Teilsprache von Java (3)
Nachteile:
• Da klassenlose, rein prozedurale Programmierung von Java nicht
Zur Programmierung verwenden wir eine Teilsprache von Java.
unterstützt wird, entsteht ein notationeller Mehraufwand.
• Bestimmte Sprachelemente bleiben zunächst unerklärt.
Vorteile:
• Der Übergang zur objektorientierten Programmierung wird
Vorgehen:
einfacher.
• Der Zusammenhang zwischen prozeduraler und objektorientierter
Programmierung wird klarer.
• Basisdatentypen
• Ausdrücke
• Variablendeklarationen
• Programmstruktur und vereinfachte Notation
©Arnd Poetzsch-Heffter
TU Kaiserslautern
4. Prozedurales Programmieren
577
©Arnd Poetzsch-Heffter
4.2 Grundkonzepte prozeduraler Programmierung
TU Kaiserslautern
4. Prozedurales Programmieren
Basisdatenstrukturen in Java:
578
4.2 Grundkonzepte prozeduraler Programmierung
Ausdrücke in Java:
Java bietet insbesondere Basisdatenstrukturen mit den Typen
boolean
char
int , long , short ,
float , double
Mittels der Konstanten und Funktionen der elementaren
Datenstrukturen lassen sich analog zu Haskell Ausdrücke bilden.
(Darüber hinaus kann man deklarierte Prozeduren in Ausdrücken
aufrufen. Dadurch können bei der Auswertung von Ausdrücken
Seiteneffekte entstehen.)
sowie entsprechende Funktionen und Konstanten.
Die nichtstrikten Operationen sind:
_?_ : _
_ && _
_ || _
©Arnd Poetzsch-Heffter
statt
wie
wie
if _ then _ else _
in Haskell
in Haskell
TU Kaiserslautern
in Haskell
579
©Arnd Poetzsch-Heffter
TU Kaiserslautern
580
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
4. Prozedurales Programmieren
Beispiel: (Ausdrücke in Java)
4.2 Grundkonzepte prozeduraler Programmierung
Variablendeklarationen in Java:
Eine Variablendeklaration hat die Form:
5 + 89
45 / 6
47474747 L * a
23+3
d == 78 + e
7 >= 45 == true
abs(a) + abs(d)
sein | !sein
true || tuEs ()
a > b ? a : b
<Typbezeichner >
für geeignetes a
<Variablenbezeichner > ;
und definiert eine neue Variable vom angegebenen Typ mit dem
angegebenem Bezeichner. Beispiele:
für geeignete d, e
int a;
boolean b;
float meineGleitkommavariable ;
char cvar;
für geeignete a, d, abs
für geeignete Variable sein
für geeignete Prozedur tuEs
// liefert max(a, b)
Eine Variablendeklarationsliste entsteht durch Aneinanderreihen von
einzelnen Deklarationen.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
4. Prozedurales Programmieren
581
©Arnd Poetzsch-Heffter
4.2 Grundkonzepte prozeduraler Programmierung
TU Kaiserslautern
4. Prozedurales Programmieren
Programmstruktur und -syntax:
582
4.2 Grundkonzepte prozeduraler Programmierung
Programmstruktur und -syntax: (2)
<Programmname>.java
public class <Programmname > {
static <Typdeklaration 1 >
...
static <Typdeklaration k >
static <Variablendeklaration 1 >
...
static <Variablendeklaration m >
static <Prozedurdeklaration 1 >
...
static <Prozedurdeklaration n >
public static void main( String [] args)
<Prozedurrumpf >
}
Ein prozedurales Programm besteht aus:
• einer Liste von Typdeklaration
• einer Liste von globalen Variablendeklarationen
• einer Liste von Prozedurdeklarationen
• einer Hauptprozedur
In Java lassen sich prozedurale Programme mit folgendem
Programmrahmen formulieren:
wobei k ≥ 0, m ≥ 0, n ≥ 0.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
583
©Arnd Poetzsch-Heffter
TU Kaiserslautern
584
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
4. Prozedurales Programmieren
Bemerkung:
4.2 Grundkonzepte prozeduraler Programmierung
Konventionen:
• Wir gehen davon aus, dass die Datei InputOutput.java im
aktuellen Dateiverzeichnis liegt. Sie stellt bereit:
• Die Reihenfolge der Deklarationen kann vertauscht werden.
public class IO
public static
public static
public static
public static
public static
}
• Die hier nicht erklärten Sprachkonstrukte werden in Kapitel 5
behandelt.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
4. Prozedurales Programmieren
585
©Arnd Poetzsch-Heffter
4.2 Grundkonzepte prozeduraler Programmierung
TU Kaiserslautern
4. Prozedurales Programmieren
Konventionen: (2)
586
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Notation prozeduraler Programme)
Foo.java
• Mit den Prozeduren print und println können insbesondere
Werte und Objekte der Typen int, char und String ausgegeben
werden.
• Im Folgenden werden wir die ersten beiden und die letzte Zeile
TU Kaiserslautern
public class Foo {
static int a;
static boolean bvar;
static int abs( int n ) {
if( n >= 0 ){
return n;
} else {
return -n;
}
}
des Programmschemas der letzten Folie sowie die
Schlüsselwörter static und public auf Folien der
Übersichtlichkeit halber weglassen.
©Arnd Poetzsch-Heffter
{
int readInt (){.. .}
String readString (){...}
char readChar (){...}
void print( Object o){...}
void println ( Object o){...}
587
©Arnd Poetzsch-Heffter
TU Kaiserslautern
588
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
4. Prozedurales Programmieren
Beispiel: (Notation prozeduraler Programme) (2)
Beispiel: (Notation prozeduraler Programme) (3)
Abkürzend schreiben wir hier:
static void setA () {
a = abs(a);
}
int a;
boolean bvar;
public static void main( String [] args ){
IO. println (" Eingabe von a:");
a = IO. readInt ();
setA ();
IO. println ( a );
}
int abs( int n ) {
if( n≥0 ){
return n;
} else {
return -n;
}
}
}
©Arnd Poetzsch-Heffter
4.2 Grundkonzepte prozeduraler Programmierung
TU Kaiserslautern
4. Prozedurales Programmieren
589
©Arnd Poetzsch-Heffter
4.2 Grundkonzepte prozeduraler Programmierung
TU Kaiserslautern
4. Prozedurales Programmieren
Beispiel: (Notation prozeduraler Programme) (4)
590
4.2 Grundkonzepte prozeduraler Programmierung
Überblick übers weitere Vorgehen:
• Anweisungen
void setA () {
a = abs(a);
}
• Prozeduren
• Variablen in Programm und Speicher
void main( String [] args ){
println (" Eingabe von a:");
a = readInt ();
setA ();
println ( a );
}
• Felder
• Benutzerdefinierte Typen
• Sichtbarkeit von Bindungen
• Iteration und Rekursion
• Weitere prozedurale Sprachkonzepte
©Arnd Poetzsch-Heffter
TU Kaiserslautern
591
©Arnd Poetzsch-Heffter
TU Kaiserslautern
592
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
4. Prozedurales Programmieren
Bemerkung:
4.2 Grundkonzepte prozeduraler Programmierung
Unterabschnitt 4.2.2
• Die Konzepte sind rekursiv von einander abhängig:
I
Anweisungen benutzen Variablen und Ausdrücke
I
Prozeduren basieren auf Anweisungen
I
Verwendung von Variablen kann nur im Kontext von Anweisungen
und Prozeduren erklärt werden.
I
Ausdrücke erlauben die Verwendung von Prozeduren.
Anweisungen
• In der programmiersprachlichen Realisierung der Konzepte
verwischen ihre Grenzen; z.B.:
I
Parameter lassen sich wie Variable verwenden.
I
Einfache Anweisungen lassen sich in Ausdrücken verwenden.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
4. Prozedurales Programmieren
593
©Arnd Poetzsch-Heffter
4.2 Grundkonzepte prozeduraler Programmierung
TU Kaiserslautern
4. Prozedurales Programmieren
Begriffsklärung: (Anweisung)
594
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Anweisungen)
1. Zuweisung eines Werts an eine Variable:
Anweisungen sind programmiersprachliche Beschreibungsmittel:
<Variable > = <Wert > ;
• Einfache Anweisungen beschreiben Aktionen.
2. Schleifenanweisung:
• Zusammengesetzte Anweisungen beschreiben, wie mehrere
Aktionen auszuführen sind, also Teile von Algorithmen.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
while( <Bedingung > ) {
<Anweisungen >
}
595
©Arnd Poetzsch-Heffter
TU Kaiserslautern
596
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
4. Prozedurales Programmieren
Bemerkung:
4.2 Grundkonzepte prozeduraler Programmierung
Bemerkung: (2)
Wir betrachten die folgenden Anweisungen und ihre Realisierung in
Java:
Unterschied: Anweisung / Ausdruck
• Einfache Anweisungen:
• Die Auswertung von Ausdrücken liefert ein Ergebnis.
• Die Ausführung von Anweisungen verändert den Zustand. Im Allg.
liefert sie kein Ergebnis.
I
Zuweisung
I
Prozeduraufruf
• Anweisungsblöcke
• Schleifenanweisungen:
I
©Arnd Poetzsch-Heffter
TU Kaiserslautern
4. Prozedurales Programmieren
597
while-, do-, for-Anweisung
©Arnd Poetzsch-Heffter
4.2 Grundkonzepte prozeduraler Programmierung
TU Kaiserslautern
4. Prozedurales Programmieren
Bemerkung: (3)
598
4.2 Grundkonzepte prozeduraler Programmierung
Einfache Anweisungen
• Verzweigungsanweisungen:
Zuweisung: (engl. assignment)
I
bedingte Anweisung
I
Fallunterscheidung
I
Auswahlanweisung
Syntax in Java:
<Variable >
Abbruchanweisung
I
Rückgabeanweisung
©Arnd Poetzsch-Heffter
<Ausdruck > ;
Semantik:
Werte den Ausdruck aus und weise das Ergebnis der Variablen zu. (In
Java ist eine Zuweisung syntaktisch ein Ausdruck, liefert also einen
Wert und zwar das Ergebnis der Auswertung von der rechten Seite der
Zuweisung.)
• Sprunganweisungen:
I
=
TU Kaiserslautern
599
©Arnd Poetzsch-Heffter
TU Kaiserslautern
600
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Einfache Anweisungen (2)
Bemerkung:
Beispiele:
In einer Zuweisung (und anderen Sprachkon- strukten) kann eine
Variable v mit zwei Bedeutungen vorkommen:
a = 27 % 23;
b = true;
meineGleitkommavariable = 3.14;
1. Das Vorkommen links vom Zuweisungszeichen meint die Variable.
Man spricht vom L-Wert (engl. l-value) des Ausdrucks v .
2. Das Vorkommen rechts vom Zuweisungszeichen meint den in v
gespeicherten Wert. Man spricht
vom R-Wert (engl. r -value) des Ausdrucks v .
Sprechweise:
"Variable b ergibt sich zu true" oder
"Variable b wird true zugewiesen".
Die Unterscheidung wird wichtiger, wenn auch links des
Zuweisungszeichens komplexere Ausdrücke stehen.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
4. Prozedurales Programmieren
601
©Arnd Poetzsch-Heffter
4.2 Grundkonzepte prozeduraler Programmierung
TU Kaiserslautern
4. Prozedurales Programmieren
Beispiel: (L-Wert, R-Wert)
602
4.2 Grundkonzepte prozeduraler Programmierung
Prozeduraufruf: (engl. procedure call)
Syntax:
%
L-Wert
a = 7 + a;
<Prozedurbezeichner > ( <AktuelleParameterliste > ) ;
<AktuelleParameterliste > → ε | <Ausdrucksliste >
<Ausdrucksliste > → <Ausdruck >
| <Ausdruck > , <Ausdrucksliste >
R-Wert
Semantik:
Werte die Ausdrücke der aktuellen Parameter aus. übergebe die
Ergebnisse an die formalen Parameter. Führe die Anweisungen der
Prozedur aus. Liefere den Rückgabewert, wenn vorhanden.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
603
©Arnd Poetzsch-Heffter
TU Kaiserslautern
604
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Prozeduraufruf: (engl. procedure call) (2)
Anweisungsblöcke
Beispiele:
Ein Anweisungsblock (engl. block statement) ist eine Liste bestehend
aus Deklarationen und Anweisungen.
Syntax in Java:
1. Prozeduraufruf mit Ergebnis:
{ <DeklAnweisListe > }
<DeklAnweisListe > → ε
| <Deklaration >
| <Anweisung >
| <Deklaration > <DeklAnweisListe >
| <Anweisung > <DeklAnweisListe >
a = ggt(a,abs (45 -87));
// Zuweisung
2. Prozeduraufruf mit Seiteneffekt:
print ( ggt (24 ,248));
Semantik:
// Anweisung
Stelle den Speicherplatz für die Variablen bereit und führe die
Anweisungen der Reihe nach aus.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
4. Prozedurales Programmieren
605
©Arnd Poetzsch-Heffter
4.2 Grundkonzepte prozeduraler Programmierung
TU Kaiserslautern
4. Prozedurales Programmieren
606
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel:
Schleifenanweisungen
{ int i; i = 7; int a; a = 27 % i; }
Schleifenanweisungen (engl. loop statements) steuern die iterative,
d.h. wiederholte Ausführung von Anweisungen/Anweisungsblöcken.
while-Anweisung:
Üblicherweise schreibt man Deklarationen und Anweisungen
untereinander, so dass ein Textblock entsteht.
{
}
int
int
i =
x =
Syntax in Java:
while ( <boolescherAusdruck > )
i;
x;
readInt ();
abs(i);
©Arnd Poetzsch-Heffter
<Anweisung >
Semantik:
Werte den Ausdruck aus, die sogenannte Schleifenbedingung. Ist
die Bedingung erfüllt, führe die Anweisung aus, den sogenannten
Schleifenrumpf , und wiederhole den Vorgang. Andernfalls beende
die Ausführung der Schleifenanweisung.
TU Kaiserslautern
607
©Arnd Poetzsch-Heffter
TU Kaiserslautern
608
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
4. Prozedurales Programmieren
Beispiel:
4.2 Grundkonzepte prozeduraler Programmierung
do-Anweisung:
Aus der Prozedur ggt:
while(
{
v =
n =
m =
}
m >0 )
n % m;
m;
v;
while (
v =
n =
m =
}
Syntax in Java:
m >0 ) {
n % m;
m;
v;
do
<Anweisung >
while( <boolescherAusdruck > ) ;
Semantik:
Führe die Anweisung aus. Werte danach den booleschen Ausdruck
aus. Ist die Bedingung erfüllt ist, wiederhole den Vorgang. Andernfalls
beende die Ausführung der Schleifenanweisung.
Bemerkung:
Der Schleifenrumpf ist in den meisten Fällen ein Anweisungsblock.
Syntaktisch korrekt ist aber auch z.B.:
while ( true ) print(i);
©Arnd Poetzsch-Heffter
TU Kaiserslautern
4. Prozedurales Programmieren
609
©Arnd Poetzsch-Heffter
4.2 Grundkonzepte prozeduraler Programmierung
TU Kaiserslautern
4. Prozedurales Programmieren
Bemerkung:
610
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel:
Wir betrachten die Ausgabe der Elemente einer nicht-leeren Liste. Wir
gehen davon aus, dass es einen Typ IntList mit Prozeduren head, tail
und isempty gibt:
Die do-Anweisung ist immer dann sinnvoll, wenn man einen Vorgang
mindestens einmal ausführen muss.
In solchen Situationen spart man sich gegenüber der Verwendung der
while-Schleife die anfänglich unnötige Auswertung der Bedingung.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
611
IntList grades ;
int g;
...
// Zuweisung an die Variable noten
// Ausgabe der nicht - leeren Notenliste
do {
g = head( grades );
println (g);
grades = tail( grades );
} while( ! isempty ( grades ) );
©Arnd Poetzsch-Heffter
TU Kaiserslautern
612
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
4. Prozedurales Programmieren
Beispiel: (2)
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Zählanweisung)
// Skalarprodukt
void main( String [] args ){
int i;
// zwei Vektoren mit jeweils 3 Elementen
int v1 [] = new int [3];
int v2 [] = new int [3];
int skalprod ;
for-Anweisung (Zählanweisung):
Die for-Anweisung dient vorrangig zur Bearbeitung von Vektoren und
Matrizen, deren einzelne Komponenten über Indizes angesprochen
werden.
Wir betrachten zunächst ein Beispiel:
v1 [0] = 1;
v1 [1] = 3;
v1 [2] = 8;
©Arnd Poetzsch-Heffter
TU Kaiserslautern
4. Prozedurales Programmieren
613
4.2 Grundkonzepte prozeduraler Programmierung
4.2 Grundkonzepte prozeduraler Programmierung
for(< Ausdrucksanweisung1 > ;
<boolescherAusdruck > ;
<Ausdrucksanweisung2 > )
skalprod = 0;
for( i = 0; i <3; i++ ) {
skalprod = skalprod + v1[i]* v2[i] ;
}
println ( skalprod );
TU Kaiserslautern
614
Syntax in Java:
v2 [0] = 2;
v2 [1] = 3;
v2 [2] = 4;
©Arnd Poetzsch-Heffter
TU Kaiserslautern
4. Prozedurales Programmieren
Beispiel: (Zählanweisung) (2)
}
©Arnd Poetzsch-Heffter
<Anweisung >
<Ausdrucksanweisung > → <Variable > = <Ausdruck >
|
<Variable > ++
|
<Variable > --
615
©Arnd Poetzsch-Heffter
TU Kaiserslautern
616
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Semantik:
Verzweigungsanweisungen
Ausdrucksanweisung:
Verzweigungsanweisungen (engl. branch statements) stellen
Bedingungen an die Ausführung einer Anweisung oder wählen einen
von mehreren Zweigen zur Ausführung aus.
Bedingte Anweisung:
1. Produktion: wie bei Zuweisung.
Syntax in Java:
2./3. Produktion: Lese den Wert der Variablen.
Erhöhe/erniedrige den Wert der Variablen um 1.
Liefere den gelesenen Wert zurück.
if( <boolescherAusdruck > )
<Anweisung >
Semantik:
Werte den Ausdruck aus. Ist das Ergebnis true, führe die Anweisung
aus. Andernfalls ist die Ausführung sofort beendet.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
4. Prozedurales Programmieren
617
©Arnd Poetzsch-Heffter
4.2 Grundkonzepte prozeduraler Programmierung
TU Kaiserslautern
4. Prozedurales Programmieren
Beispiel: (Bedingte Anweisung)
Fallunterscheidung:
if( i != 0 ) { n = k/i; }
Syntax in Java:
if(
{
}
if( <boolescherAusdruck > )
else
gute_Idee_vorhanden
&& genug_Zeit_zur_Vorbereitung )
halte_anregende_Weihnachtsvorlesung ();
mache_schneller_damit_frueher_fertig ();
©Arnd Poetzsch-Heffter
TU Kaiserslautern
618
4.2 Grundkonzepte prozeduraler Programmierung
<Anweisung1 >
<Anweisung2 >
Semantik:
Werte den Ausdruck aus. Ist das Ergebnis true, führe Anweisung1,
andernfalls Anweisung2 aus.
619
©Arnd Poetzsch-Heffter
TU Kaiserslautern
620
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Fallunterscheidung)
Auswahlanweisung:
if( i!=0 ) {
n = k/i;
n++;
} else {
fehlerbehandlung (" Division durch Null");
}
Auswahlanweisungen erlauben es, in Abhängigkeit von dem Wert
eines Ausdrucks direkt in einen von endlich vielen Fällen zu
verzweigen. In Java gibt es dafür die switch-Anweisung. Wir verzichten
hier auf eine genaue Beschreibung von Syntax und Semantik und
betrachten ein Beispiel:
©Arnd Poetzsch-Heffter
TU Kaiserslautern
4. Prozedurales Programmieren
621
4.2 Grundkonzepte prozeduraler Programmierung
622
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Auswahlanweisung) (2)
wobei proza, prozb, prozc beliebige Prozeduren sind, zum Beispiel:
void main( String [] args ){ // AuswahlanweisungsTest
char c;
boolean machWeiter = true;
do {
print ("Ein Zeichen aus {a,b,c,e}:");
c = readChar ();
switch ( c ) {
case ’a’: proza (); break ;
case ’b’: prozb (); break ;
case ’c’: prozc (); break ;
case ’e’:
machWeiter = false; break ;
default :
print (" Falsches Eingabezeichen ");
}
} while ( machWeiter );
}
TU Kaiserslautern
TU Kaiserslautern
4. Prozedurales Programmieren
Beispiel: (Auswahlanweisung)
©Arnd Poetzsch-Heffter
©Arnd Poetzsch-Heffter
void proza () {
/* hier koennte ’was Interessantes stehen */
println (" Ich bin Prozedur A. Alles gut ?");
println (" Probleme mit dem Weina ’stress ?\n");
}
void prozb () {
/* hier natuerlich auch */
println ("Wer A sagt , muss auch B sagen.");
println ("Haben Sie schon A gesagt .\n");
}
void prozc () {
println ("C wie no comment . Cool ,oder ?\n");
}
623
©Arnd Poetzsch-Heffter
TU Kaiserslautern
624
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
4. Prozedurales Programmieren
Sprunganweisungen
4.2 Grundkonzepte prozeduraler Programmierung
Abbruchanweisung:
Syntax in Java:
Sprunganweisungen (engl. jump statements) legen eine
Fortsetzungsstelle der Ausführung fest, die möglicherweise weit von
der aktuellen Anweisung entfernt liegt. Wir betrachten hier nur
Sprünge, die der Programmstruktur folgen.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
4. Prozedurales Programmieren
break;
Semantik:
Die Ausführung wird am Ende der umfassenden zusammengesetzen
Anweisung fortgesetzt.
625
©Arnd Poetzsch-Heffter
4.2 Grundkonzepte prozeduraler Programmierung
TU Kaiserslautern
4. Prozedurales Programmieren
Beispiel: (Auswahlanweisung)
626
4.2 Grundkonzepte prozeduraler Programmierung
Rückgabeanweisung:
Syntax in Java:
return ;
return <Ausdruck > ;
1. In Auswahlanweisung: siehe oben.
Semantik:
2. In Schleifenanweisungen:
1. Fall/Produktion:
Nur in Prozeduren ohne Rückgabewert erlaubt. Beende die
Ausführung der Prozedur. Setze die Ausführung an der
Aufrufstelle fort.
while ( true ) {
...
if( <Abbruchbedingung > ) break ;
...
}
©Arnd Poetzsch-Heffter
TU Kaiserslautern
2. Produktion:
Nur in Prozeduren mit Rückgabewert erlaubt. Werte den Ausdruck
aus. Beende die Ausführung der Prozedur. Liefere den Wert des
Ausdrucks als Ergebnis und setze die Ausführung an der
Aufrufstelle fort.
627
©Arnd Poetzsch-Heffter
TU Kaiserslautern
628
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
4. Prozedurales Programmieren
Beispiel: (Rückgabeanweisung)
Unterabschnitt 4.2.3
int abs( int n ) {
if( n ≥ 0 ) {
return n;
} else {
return -n;
}
}
©Arnd Poetzsch-Heffter
4.2 Grundkonzepte prozeduraler Programmierung
Prozeduren
TU Kaiserslautern
4. Prozedurales Programmieren
629
©Arnd Poetzsch-Heffter
4.2 Grundkonzepte prozeduraler Programmierung
TU Kaiserslautern
4. Prozedurales Programmieren
Prozeduren
630
4.2 Grundkonzepte prozeduraler Programmierung
Begriffsklärung: (Prozedur)
Prozeduren erlauben es, von konkreten Anweisungen bzw.
Anweisungssequenzen zu abstrahieren.
Eine Prozedur ist eine Abstraktion einer Anweisung. Sie gibt der
Anweisung einen Namen und legt fest, das die Parameter der
Anweisung sind. Prozeduren können Ergebnisse liefern.
D.h. Prozeduren legen die Parameter einer zusammengesetzten
Anweisung fest und geben ihr einen Namen.
Dies ermöglicht:
Bemerkung
• Wiederverwendung,
Prozeduren abstrahieren Anweisungen genauso, wie Funktionen
Ausdrücke abstrahieren.
• Schnittstellenbildung und Information Hiding.
Darüber hinaus ermöglichen Prozeduren die rekursive Ausführung von
Anweisungen.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
631
©Arnd Poetzsch-Heffter
TU Kaiserslautern
632
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
4. Prozedurales Programmieren
Beispiel: (Prozedur als Abstraktion
Beispiel: (Prozedur als Abstraktion (2)
Aufgabe:
Berechne den Absolutbetrag einer ganzen Zahl gespeichert in Variable
i und schreibe ihn in die Variable x.
void
int
int
i =
}
TU Kaiserslautern
4. Prozedurales Programmieren
633











 Abstraktion bzgl. i,



result wird zum Ergebnis.








x = result ;
©Arnd Poetzsch-Heffter
4.2 Grundkonzepte prozeduraler Programmierung
TU Kaiserslautern
4. Prozedurales Programmieren
Beispiel: (Prozedur als Abstraktion (3)
634
4.2 Grundkonzepte prozeduraler Programmierung
Deklaration von Prozeduren/Methoden:
int abs( int n ) {
if( n ≥ 0 ) {
return n;
} else {
return -n;
}
}
Syntax in Java:
<Typ > <Prozedurbezeichner > ( <formaleParameter > )
<Anweisungsblock >
Semantik:
Die Semantik ist durch den Aufrufmechanismus und den
Anweisungsblock, den sogenannten Prozedurrumpf bestimmt
(Genaueres siehe unten).
void main(...){
int i;
int x;
i = readInt ();
}
main(.. .){
i;
x;
readInt ();
int result ;
if( i>=0 ) {
result = i;
} else {
result = -i;
}
Algorithmus:
Wenn i größer oder gleich 0, liefere i als Ergebnis; andernfalls −i.
Weise das Ergebnis an x zu.
©Arnd Poetzsch-Heffter
4.2 Grundkonzepte prozeduraler Programmierung
x = abs(i);
©Arnd Poetzsch-Heffter
TU Kaiserslautern
635
©Arnd Poetzsch-Heffter
TU Kaiserslautern
636