2.2.1.5. Struktogramme

Nächste Seite

Bevor ein Programm geschrieben werden kann, ist es notwendig, dass sich der Programmierer einen Algorithmus zur Problemlösung überlegt, welchen er später in Programmbefehlen formulieren will. Aber auch die Struktur des Programmes, in der der Datenfluss beschrieben wird, kann vor dem Schreiben des eigentlichen Quelltextes notiert werden. Zu diesem Zwecke gibt es sogenannte Struktogramme. Diese Darstellung wurde von I. Nassi und Ben Shneiderman entwickelt und ist auch unter dem Namen "Nassi-Shneiderman-Diagramm" bekannt. Bei Struktogrammen handelt es sich um eine strukturierte graphische Darstellung des Datenflusses in Programmstrukturblöcken. Sie dienen als Hilfsmittel in der Strukturierten Programmierung und werden unter Verwendung einheitlicher Darstellungssymbole und Zeichen erstellt. Ein Struktogramm ist somit eine Art graphische Darstellung des Quelltextes. Die algorithmischen Strukturen (z.B. Schleifen, Verzweigungen) werden damit schon vorher festgelegt und müssen dann nur noch in den eigentlichen Programmcode "umformuliert" werden.

Die einfachste Form eines Struktogrammes ist die Darstellung einer Sequenz, d.h. einer Abfolge von Programmbefehlen:

sequenz.gif (1632 Byte)

Die Erstellung von Struktogrammen ist keine Pflicht und eigentlich nur in strukturierten Programmiersprachen, wie  beispielsweise Pascal, üblich. Dennoch ist ihre Verwendung auch bei TI-85 BASIC Programmen zu empfehlen. Obwohl es sich bei TI-85 BASIC nicht um eine strukturierte Programmiersprache im eigentlichen Sinne handelt, sind Struktogramme sehr hilfreich. Sie verdeutlichen die Programmstrukturen und vereinfachen das Programmieren. Sie sind übersichtlicher als der unstrukturierte TI-85 BASIC Quelltext und der Programmablauf ist auf den ersten Blick überschaubar.
Sobald Sprungmarken und "Goto- Anweisungen" verwendet werden, nützen Struktogramme allerdings nur noch wenig, da sie dadurch fast ebenso unübersichtlich wie der gesamte Programmcode werden.

2.2.1.6. Kontrollstrukturen: Bedingte Anweisungen

Für die Formulierung von Algorithmen benötigt man Steueranweisungen, in welchen die Reihenfolge, in der Operationen und Anweisungen ausgeführt werden sollen, festgelegt wird. Diese Steueranweisungen bilden die Kontrollstruktur eines Programmes. Vereinfacht gesagt, bestimmen die Steueranweisungen welche Anweisung wann ausgeführt wird. Sie "verteilen sozusagen die Aufgaben".
Es gibt verschiedene Arten von Kontrollstrukturen. Die einfachste ihrer Art ist eine festgelegte Reihenfolge von Anweisungen: "Tue erst das, dann das, danach das usw". Nach dieser sequentiellen Abarbeitung geht der Interpreter vor. Es wird solange die folgende Anweisung bearbeitet, bis das Programm beendet ist.
Oft besteht ein Programm aber nicht nur aus einer einfachen Reihenfole von Befehlen, denn nicht immer soll auch wirklich die Anweisung ausgeführt werden, die in der nächsten Zeile steht. Aus diesem Grunde gibt es so genannte "Bedingte Anweisungen".
Der bekannteste Vertreter ist die "
If - Then" Struktur. Diese Struktur, die auf deutsch übersetzt "wenn - dann" heisst, stellt eine Bedingung. Nur wenn diese Bedingung erfüllt ist, wird die folgende Anweisung ausgeführt. Es wird also kontrolliert, ob eine gestellte Bedingung zutrifft und wenn dies der Fall ist, erhält die folgende Anweisung den "Startbefehl".
Diese Steueranweisung wird in TI-85 BASIC folgendermaßen formuliert:

:If [Bedingung]
:Then
:[Anweisungen wenn wahr]
:End

Steht im "Then- Teil" nur eine einzige Anweisung, so können "Then" und "End" weggelassen werden. Ohne anschließendes "Then" wird nur die nächstfolgende Anweisung bedingt ausgeführt. "Then" wird verwendet, wenn es sich um einen folgenden Anweisungblock handelt, oder wenn ein "Else" folgt. Es verlangt immer ein "End".
Hinweis: Der "
Else- Zweig" kann nicht auf ähnliche Weise verkürzt werden. Auch wenn sich nur ein Befehl hinter "Else" befindet, so muss ein "End" stehen.

:If [Bedinging]
:[Anweisung wenn wahr]

Mit Hilfe der bedingten Anweisung kann das Programm individueller auf bestimmte Sachverhalte eingehen. Ein Beispiel wäre folgendes: Wenn das Wetter heute schön ist, werden wir eine Gartenparty machen, aber nur dann. Im Schlechtwetterfall, könnte man sich die Mühe sparen und die Anweisungen brauchten nicht ausgeführt werden.
Was ist aber, wenn es in unserem Beispiel wirklich anfangen sollte zu regnen ? Eine Gartenparty wird es sicherlich nicht geben, aber wie wäre es mit einem gemütlichen Fernsehabend ? Es sollte doch eine Alternative geben, für den Fall, dass die Bedingung nicht erfüllt ist.
Diese Alternative gibt es in einer 2. Form der bedingten Anweisung. Die "
If - Then" Struktur wird erweitert und heisst jetzt "If - Then - Else". Das bedeutet, wenn di Bedingung erfüllt ist, dann tue dies, sonst tue jenes. Es wird dabei in jedem Fall einer der beiden Anweisungszweige ausgeführt. Ist die Bedingung erfüllt, so wird Anweisung 1 ausgeführt und Anweisung 2 übersprungen. Ist die Bedingung nicht erfüllt, geschieht das Gegenteil, Anweisung 2 wird ausgeführt und Anweisung 1 übersprungen.

:If [Bedingung]
:Then
:[Anweisungen]
:Else
:[Anweisungen]
:End

Die Ausdruck, der eine Bedingung formuliert, ist normalerweise ein Vergleichstest, d.h. zwei Werte werden miteinander verglichen (z.B. 1<5, A>7 oder B==C).
Der Vergleichstest liefert einen Wert zurück, welcher den Wert des ganzen Ausdrucks der Bedingung bestimmt. Ist der Vergleich wahr (z.B. 3<4, 3==(1+2)), so ist der zurückgegebene Wert ungleich Null. Ist der Vergleich aber falsch (z.B. (22/2)==10, 3==4) so ist der interne Wert des Ausdrucks gleich 0.
Davon ausgehend kann der Ausdruck, der die Bedingung angibt, auch nur aus einer Zahl oder einer Variablen bestehen. Der Rechner überprüft dann nur, ob die Variable zum Zeitpunkt der bedingten Anweisung gleich Null (Bedingung nicht erfüllt) oder ungleich Null (Bedingung erfüllt) ist.

In den Anweisungszweigen (d.h. alles, was hintern "Then" oder "Else" kommt) können beliebig viele Anweisungen stehen, die alle mit Doppelpunkt voneinander getrennt werden müssen. Nach dem letzten zum Anweisungszweig gehörenden Befehl muss ein "End" stehen. Dieses "End" signalisiert dem Interpreter das Ende der bedingten Anweisung. Wird das "End" nicht gesetzt, kommt es im Programmablauf zu Fehlermeldungen und falschen Ergebnissen. Im "Then" Zweig braucht kein "End" gesetzt werden, wenn danach ein "Else" folgt, da dies automatisch das Ende des "Then" Zweiges markiert.

Beispiele für Bedingungen in TI-85 BASIC

Bsp. Bedingung Ergebnis
1 :3®A
:If A :Then :[Anweisungen] :End
wahr / 1
2 :If (A<4) :Then :[Anwiesungen] :End wahr / 1
3 :4®B
:If (A<B) and (A>5) :Then :[Anweisungen] :End
falsch / 0
4 :If (1==(2-1)) or (A<B) :Then :[Anweisungen] :End wahr / 1
5 :If (2==2) xor (3==(4-1)) :Then :[Anweisungen] :End falsch / 0

Beispiele für bedingte Anweisungen in TI-85 BASIC:

Bsp. Anweisungen Ausgabe
6 :5®D
:If D<4 :Disp "D ist kleiner als 4"
 
7 :(10*rand)®C
:If C<5 :Then :Disp "C ist kleiner als 5!"
:Else :Disp "C ist groesser oder gleich 5!" :End
C ist kleiner als 5
8 :(3/4)®E :(5/6)®F :(3/8)®G
:If (E<F) and (E<G) :Then :E
®MIN :"E"®VAR
:Else
:If (F<E) and (F<G) :Then :F
®MIN :"F"®VAR
:Else :G
®MIN :"G"®MIN
:End :End
:Disp "Das Minimum ist:"
:Outpt(1,1,VAR)
:Outpt(1,3,MIN)
Das Minimum ist:
G  0.375

If- Anweisungen können verschachtelt werden. Wie in Beispiel 8 können im Else- Zweig belieblig viele weitere If- Anweisungen folgen und somit weitere Bedingungen gestellt und dementsprechende Alternativen angeboten werden.
Grundsätzlich gehört zu jedem "If" auch ein "End", dies ist bei verschachtelten If- Then- Else Anweisungen besonders wichtig, da ein vergessenes "End" unweigerlich zu Fehlern im Programmablauf führt.

Struktorgrammdarstellung der Bedingten Anweisungen:

1. Form der Bedingten Anweisung

ifthen_struk.gif (1745 Byte)

2. Form der Bedingten Anweisung

ifthenelse_struk.gif (1989 Byte)