Warnung: In Bearbeitung!

Dieser Teil des Tutorials ist erst im Entstehen begriffen. Schau doch bitte auch später noch einmal vorbei!

Programme unter BlitzBasic/AmiBlitz3 werden „top down“ von oben nach unten abgearbeitet – doch es gibt Ausnahmen zu diesem Paradigma. Einige davon, wie z.B. Prozeduren, hast du bereits kennen gelernt.

Ein Programm, das stur der Reihe nach nur einen Befehl nach dem anderen abarbeitet, ist nicht sehr flexibel und wäre unnötig lang und anstrengend zu schreiben. Was ist, wenn bestimmte Befehlsfolgen mehrfach hintereinander ablaufen sollen? Oder wie sieht’s aus, wenn das Programm unterschiedlich auf verschiedene Bedingungen reagieren muss? Nun, für solche Fälle verfügt BlitzBasic über mächtige Kontroll- strukturen, die Fallunterscheidungen und bedingte Verzweigungen genauso ermöglichen, wie Wiederholungsschleifen – und darum geht es in diesem Teil des Tutorials.

Bedingungen auswerten

Als Programmierer steht man häufig vor dem Problem, dass das Programm mit unterschiedlichen Reaktionen auf bestimmte Bedingungen reagieren muss. BlitzBasic bringt für diesen Zweck verschiedene Kontrollstrukturen mit, die alle auf unterschiedliche Bedingungen hin zu unterschiedlichen Programmteilen verzweigen.

If … Then … Else … EndIf

Die If-Anweisung kommt gleich in mehreren Geschmacksrichtungen:

Variante 1 reagiert auf eine Bedingung und wenn diese zutrifft, so werden die Befehle im Anweisungsblock ausgeführt. Trifft die Bedingung nicht zu, dann wird die if-Anweisung übersprungen und das Programm danach fortgesetzt.

Variante 2 reagiert auf eine Bedingung und wenn diese zutrifft, so werden die Befehle im Anweisungsblock ausgeführt. Trifft die Bedingung nicht zu, dann wird der Anweisungsblock im Else-Teil abgearbeitet und das Programm danach fortgesetzt.

Die Varianten 1 und 2 benötigen das Schlüsselwort EndIf, um abgeschlossen zu sein.

Variante 3 reagiert auf eine Bedingung und wenn diese zutrifft, so wird der darauf folgende Befehl ausgeführt. Trifft die Bedingung nicht zu, dann wird die if-Anweisung übersprungen und das Programm danach fortgesetzt. Diese Variante benötigt nicht das Schlüsselwort EndIf.

Schablone:

; Variante 1
If Bedingung   
  ... Anweisungsblock ...  
EndIf

oder

; Variante 2
If Bedingung
  ... Anweisungsblock ...
Else
  ... Anweisungsblock ...
EndIf

oder

; Variante 3
If Bedingung Then Anweisung

Bedingungen können einfache Vergleiche, aber auch komplizierte, zusammengesetzte Ausdrücke sein. Verdeutlichen wir uns die Zusammenhänge mit dem Listing „if.ab3“:

; ----------------------------
; File: if.ab3
; 3 x if-Anweisung
; Version: 1.0
; ----------------------------
OPTIMIZE 1
SYNTAX 1

; Amiga Version String und das Compilerdatum
!version {"if 1.0 (\\__DATE_GER__)"}

DEFTYPE .b myInput       ;Globale Variablen deklarieren

; -- Benutzer-Eingabe --
Print "Gib entweder 0 oder 1 ein: "
myInput.b = Edit(1)
NPrint ""

; -- Auswertung --
; Variante 3
If (myInput.b <> 0) AND (myInput.b <> 1)  Then NPrint "Falsche Zahl!"
If (myInput.b = 0) Then NPrint "Selber Null!"

; Variante 1
If myInput.b = 1
  NPrint "Einmal ist keinmal!"
EndIf

If myInput.b = 0
  NPrint "Eine große Null ist fast schon eine kleine Eins."
  NPrint "Die Eins wolltest du wohl nicht haben?"
EndIf

; Variante 2
If myInput.b = 1
  NPrint "Die Null wolltest du wohl nicht haben?"
Else
  NPrint "Kannst du auch was richtig?"
EndIf

End

Ausgabe:

|- Gültige Zahl: 0 -|
Gib entweder 0 oder 1 ein: 0

Selber Null!
Eine große Null ist fast schon eine kleine Eins.
Die Eins wolltest du wohl nicht haben?
Kannst du auch was richtig?

 |- Gültige Zahl: 1 -|
Gib entweder 0 oder 1 ein: 1

Einmal ist keinmal!
Die Null wolltest du wohl nicht haben?

|- Ungültige Zahl -|
Gib entweder 0 oder 1 ein: 9

Falsche Zahl!
Kannst du auch was richtig?

Programmanalyse:

Unser Programm fordert vom Benutzer die Eingabe von Null oder Eins an (Zeile 16) und gibt dann auf der Basis von Entscheidungen bestimmte Meldungen aus.

• Zeile 21 prüft mittels einer einzeiligen If-Anweisung und einer aus zwei Teilbedingungen bestehenden Bedingung, ob die eingegebene Ziffer den gestellten Anforderungen entspricht. dabei verwenden wir die logischen Vergleichsoperatoren <> und  And, um die beiden Teilbedingungen zu prüfen und miteinander zu verknüpfen. Das liest sich so:

  WENN die Eingabe ungleich Null UND die Eingabe ungleich Eins ist, DANN sage "Falsche Zahl!"

  Wir werden gleich noch intensiver über Vergleichsoperatoren sprechen – bis dahin merke dir: Der Operator für „ungleich“ ist <>, der Operator für das logische UND ist And.
  Trifft die Bedingung nicht zu, so fährt das Programm in Zeile 22 fort.

• Zeile 16 liest mittels des Befehls Edit(1) die Benutzereingabe ein. Der Parameter „(1)“ legt fest, dass der Benutzer nur eine Ziffer eingeben darf.
• Zeile 22 prüft mittels einer einzeiligen If-Anweisung und der Bedingung „ist die Eingabe identisch mit der Ziffer Null“, ob die Null gewählt wurde und gibt in diesem Fall die Meldung „Selber Null!“ aus.  Andernfalls fährt das Programm in Zeile 25 fort. Zur Überprüfung der Bedingung kommt der Gleicheitsoperator „=“ zum Einsatz: If myInput.b = 0
  Merke: Das Gleichheitszeichen ist kontextabhängig entweder der Zuweisungs- operator (z.B. Zahl = 42), oder aber der Gleichheitsoperator.
• die Zeilen 25 bis 27 stellen ein einfaches If … EndIf-Konstrukt dar, zwischen dem der Anweisungsblock steht. Der besteht hier allerdings aus nur einer Anweisung. Wenn die Bedingung „Ziffer = 1“ erfüllt ist, wird eine Meldung ausgegeben.
• die Zeilen 29 bis 32 funktionieren identisch. Hier besitzt der Anweisungsblock zwei Anweisungen.
• Zeilen 35 bis 39 bestehen aus einem If … Else … EndIf-Konstrukt: WENN die Bedingung erfüllt ist, gib eine Meldung aus, ANDERNFALLS gib eine andere Meldung aus.

So richtig rund läuft unser Programm aber noch nicht. Wir möchten, das die Meldung „Kannst du auch was richtig?“ nur bei einer Fehleingabe ausgegeben wird. Eine Lösungsmöglichkeit wäre es, anstatt einer einzeiligen If … Then …-Anweisung eine If … EndIf-Anweisung zu verwenden und beide Ausgaben in den Anweisungsblock zu packen:

...
If (myInput.b <> 0) AND (myInput.b <> 1)
  NPrint "Falsche Zahl!"
  NPrint "Kannst du auch was richtig?"
EndIf
...

Die zweite – kompliziertere – Möglichkeit besteht im Verschachteln von If-Konstrukten.

Verschachtelte If-Anweisungen

Betrachte dir die folgende Programmsequenz mit ineinander verschachtelten If-Anweisungen:

...
If (myInput.b <> 0) AND (myInput.b <> 1)  ; äußere Bedingung
  NPrint "Falsche Zahl!" 
  If myInput.b > 1                        ; innere Bedingung
    NPrint "Kannst du auch was richtig?"
  EndIf
Endif
...

Hier wird zunächst die äußere Bedingung geprüft und nur wenn sie zutrifft, dann wird die innere Bedingung abgearbeitet. Sie benutzt den Vergleichsoperator „größer als“ (>), um festzustellen, ob eine andere Ziffer als 0 oder 1 eingegeben wurde.
Solche Verschachtelungen kann man natürlich noch viel weiter vertiefen. Ich rate dir allerdings dringend davon ab. Tiefe Verschachtelungen werden schnell unübersicht- lich und sind fehleranfällig. Nur in Ausnahmefällen sollte man mehr als zwei Verschachtelungen vornehmen.

Select … Case … End Select

Die Select … Case … End Select-Strukturen sind oft der beste Weg, um einfache Informationen zu verarbeiten, die von einem Benutzer kommen. Für jedes Case können in einem Anweisungsblock mehrere Anweisungen hintereinander abgearbeitet werden.

Schablone:

Select Ausdruck ; kann eine Variable, Konstante oder Rückgabewert sein
  Case Wert 1
    ... Anweisungsblock ...
  Case Wert 2
    ... Anweisungsblock ...
  Case  weitere Werte
    ... usw ...
  Default
    ... Anweisungsblock ...
    (wird ausgeführt, wenn keine andere Bedingung zutraf)
End Select

Das Konstrukt funktioniert folgendermaßen:

• Dem Schlüsselwort Select wird ein Ausdruck übergeben. Dieser kann der Wert einer Variablen, Konstanten, der Rückgabewert einer Funktion oder eine komplexe Bedingung sein.
• Dem Schlüsselwort Case wird ein möglicher Wert dieses Ausdrucks als Bedingung übergeben. Diese wird geprüft. Trifft sie zu, dann wird der zugehörige Anweisungsblock abgearbeitet. Trifft sie nicht zu, dann wird das Programm mit dem nächsten Case fortgesetzt.
• Das Schlüsselwort Default ist optional. Der Anweisungsblock nach Default wird abgearbeitet, wenn keine der vorherigen Bedingungen zutraf.
• Das Konstrukt wird mit dem Schlüsselwort End Select abgeschlossen.
• Auch Select-Konstrukte können ineinander verschachtelt werden.

Mit Select … Case-Konstrukten können wir unser Beispiel if.ab3 bequem so umbauen, dass es genau die Ausgaben liefert, die wir erwarten. Das Listing „select.ab3“ verdeutlicht das:

; ------------------------------
; File: select.ab3
; Select ... Case ... End Select
; Version: 1.0
; ------------------------------
OPTIMIZE 1
SYNTAX 1

; Amiga Version String und das Compilerdatum
!version {"select 1.0 (\\__DATE_GER__)"}

DEFTYPE .b myInput       ;Globale Variablen deklarieren

; -- Benutzer-Eingabe --
Print "Gib entweder 0 oder 1 ein: "
myInput.b = Edit(1)
NPrint ""

; -- Auswertung --
Select myInput.b
  Case 0
    NPrint "Selber Null!"
    NPrint "Die Eins wolltest du wohl nicht haben?"
    NPrint "Eine große Null ist fast schon eine kleine Eins."
  Case 1
    NPrint "Einmal ist keinmal!"
    NPrint "Die Null wolltest du wohl nicht haben?"
  Default
    NPrint "Falsche Zahl!"
    NPrint "Kannst du auch was richtig?"
End Select

End

Ganz schön kurz und viel übersichtlicher, oder?

Programmanalyse:

• in Zeile 16 lesen wir die Benutzereingabe ein. Diese wird in den Zeilen 21 bis 31 dann mit einem Select … Case … Default-Konstrukt ausgewertet.
• Zeile 21 bestimmt, dass die Variable myInput.b durch Select ausgewertet werden soll.
• Wenn der Wert der Variablen myInput.b gleich 0 ist, so wird das Case in Zeile 21 abgearbeitet.
• Wenn der Wert der Variablen myInput.b gleich 1 ist, so wird das Case in Zeile 25 abgearbeitet.
• Wenn der Wert der Variablen myInput.b weder 0, noch 1 ist, dann wird Default in Zeile 28 abgearbeitet.

Select … Case-Konstrukte eigenen sich z.B. ideal, um Benutzermenüs aufzubauen, wie das folgende Listing „menu.ab3“ zeigt:

; ------------------------------
; File: menu.ab3
; Select ... Case ... End Select
; Version: 1.0
; ------------------------------
OPTIMIZE 1
SYNTAX 1

; Amiga Version String und das Compilerdatum
!version {"select 1.0 (\\__DATE_GER__)"}

DEFTYPE .b mySelection  ;Globale Variablen deklarieren
DEFTYPE .s myQuit

; -- Titel --
ANFANG :
NPrint "**************************"
NPrint "* Menueauswahl           *"
NPrint "* ============           *"
NPrint "* Pizza            - 1 - *"
NPrint "* Pasta            - 2 - *"
NPrint "* Leberwurst       - 3 - *"
NPrint "*                        *"
NPrint "* Programm beenden - 0 - *"
NPrint "**************************"
; -- Benutzer-Eingabe --
Print "Deine Wahl: "
mySelection.b = Edit(1)
NPrint ""

Select mySelection.b
  Case 0
    Print "Programm beenden? (j/n): "
    myQuit.s = Edit$(1)
    Select myQuit.s
      Case "j"
        End
      Case "J"
        End
      Default
        NPrint "Das Programm wird fortgesetzt..."
        NPrint ""
        Goto ANFANG
    End Select
  Case 1
    NPrint "Du hast Pizza bestellt."
    NPrint "Weiter: Maustaste"
    MouseWait
    NPrint ""
    Goto ANFANG
  Case 2
    NPrint "Du hast Pasta bestellt."
    NPrint "Weiter: Maustaste"
    MouseWait
    Goto ANFANG
  Case 3
    NPrint "Du willst Leberwurst."
    NPrint "Weiter: Maustaste"
    MouseWait
    NPrint ""
    Goto ANFANG
  Default
    NPrint "Falsche Eingabe!"
    NPrint "Weiter: Maustaste"
    MouseWait
    NPrint ""
    Goto ANFANG
End Select

End

Ausgabe:

**************************
* Menueauswahl           *
* ============           *
* Pizza            - 1 - *
* Pasta            - 2 - *
* Leberwurst       - 3 - *
*                        *
* Programm beenden - 0 - *
**************************
Deine Wahl: 0

Programm beenden? (j/n): j

Das Listing verwendet drei bisher unbekannte Elemente: Eine Sprungmarke und die Befehl Goto und MouseWait. Wir gehen nachher nochmal genauer auf die ersten beiden Elemente ein.

Programmanalyse:

Am Anfang wird das Menü ausgegeben und der Benutzer zu einer Eingabe aufgefordert, dann verzweigen wir mittels Select … Case … Default-Konstrukt zur Ausgabe einer passenden Meldung. Beachte das verschachtelte Select … Case … Default-Konstrukt bei der Sicherheitsabfrage zum Verlassen des Programms!

• die Zeilen 16 bis 28 bilden das Menü und verlangen eine Benutzereingabe.
• die Sprungmarke in Zeile 16 dient dazu, mittels des Goto-Befehls nach einer Ausgabe das Menü neu zu zeichnen.
• die Zeilen 31 bis 66 bilden das Herzstück des Programms – hier wird im einem Select … Case … Default-Konstrukt die Benutzereingabe ausgewertet und auf sie reagiert.
• das Case 0 in Zeile 32 reagiert auf die Eingabe der Ziffer 0, ist somit fürs Beenden des Programms (mit Sicherheitsabfrage) zuständig und fordert in Zeile 34 vom Benutzer eine Bestätigung an, die in der Variablen myQuit.s abgelegt wird.
• Zeile 35 wertet diese Bestätigung mittels eines weiteren Select … Case … Default-Konstrukts aus und prüft ob ein „j“ oder ein „J“ eingegeben wurde (Zeilen 36 und 38). Trifft eins der Beiden zu, so wird das Programm beendet, andernfalls wird der Default-Zweig in Zeile 40 ausgeführt und das Programm läuft weiter. Dabei springt es in Zeile 43 mit dem Befehl Goto zur Sprungmarke ANFANG. Danach wird das Programm nach der Sprungmarke fortgesetzt, was dazu führt, dass das Menü erneut aufgebaut wird.Diesen Programmabschnitt hätten wir auch mit einem If … Then … EndIf-Konstrukt lösen können, aber wenn wir schonmal dabei sind…
• Case 1 in Zeile 45 veranlasst die Ausgabe der Pizza-Meldung und springt danach wieder zu ANFANG. Damit der Benutzer nicht sofort wieder mit dem Menü konfrontiert wird, warten wir mit dem Befehl MouseWait, bis er die linke Maustaste gedrückt hat.
• Die beiden anderen Case-Anweisungen funktionieren synonym zu Case 1.

Schon ganz eindrucksvoll, aber es geht noch besser! Anstatt das Menü immer wieder nacheinander auszugeben wäre es doch schick, wenn es immer ganz oben in der Shell aufgehen würde!? Das geht – man muss der Shell dazu nur die Escape-Sequenz zum Löschen des Bildschirms senden. BlitzBasic verfügt leider nicht über einen entsprechenden Befehl, aber dafür besitzt AmiBlitz3 einen neuen Modus, der das Senden von Escape-Sequenzen erlaubt. Dafür musst du allerdings das Programm mit der Option OPTIMIZE 4 compilieren! Diese Methode ist nicht kompatibel zu BlitzBasic v2.1 und älter. Realisiert wird das Löschen des Bildschirms dann mittels zweier Print-Befehle:

Print "\\1B[1m":Print "\\1Bc"

Hinweis: Bisher haben wir Anweisungen immer nur einzeilig geschrieben – jede Anweisung für sich. BlitzBasic erlaubt es jedoch auch, mehrere eigenständige Anweisung in einer Zeile unterzubringen. Dazu trennt man die Anweisungen durch einen Doppelpunkt.

Es gibt aber auch eine abwärtskompatible Lösung (besten Dank an Rob Cranley):

Print Chr$($0c) ; kompatibel zu BlitzBasic v2.1

Um das Listing um die Möglichkeit, den Bildschirm zu löschen, zu erweitern, gehst du wie folgt vor:

1. Ändere in Zeile 6 OPTIMIZE 1 auf OPTIMIZE 4 (nur für AmiBlitz3-kompatible Lösung)
2. füge nach Zeile 16 eine Leerzeile ein und trage dort die Print-Befehle mit den erforderlichen Escape-Sequenzen ein:
   Print „\\1B[1m“:Print „\\1Bc“
   oder
   Print Chr$($0c) (kompatibel zu BlitzBasic v2.1)
3. Lösche die Zeilen 41 und 42 – ihre Ausgaben wären beim Löschen des Bildschirms ohnehin nicht mehr sichtbar.

Wenn du in einem Programm öfter den Bildschirm löschen möchtest, dann ist es übersichtlicher, die Escape-Sequenz in einer Variablen abzulegen und diese dann bei Bedarf aufzurufen:

shellClr.s = Chr$($0c) ; "sprechende" Variable
Print shellClr         ; Bildschirm löschen

Tipp: Eine Auflistung der auf dem Amiga gebräuchlichen Escape-Sequenzen findest du im AmigaOS-Wiki unter
https://wiki.amigaos.net/wiki/AmigaOS_Manual:_Control_Sequences

Aufgabe:

• Schreibe ein Programm zur Berechnung der Grundrechenarten, der Potenz zweier Zahlen und lasse es bestimmen, ob die Division zweier Ganzzahlen einen Rest besitzt (Modulo)
• Verwende für die Berechnungen Funktionen und rufe sie über ein Menü auf.
• Verwende für die Benutzereingabe der beiden Zahlen ein Statement.
  Tipp: Lokale und globale Variablen, Schlüsselwort SHARED.
• Lasse vor Aufruf der Funktion zur Division prüfen, ob der Divisor Null ist. Die Berechnung soll nur ausgeführt werden, wenn der Divisor ungleich Null ist – andernfalls soll seine Fehlermeldung ausgegeben und die Funktion nicht ausgeführt werden.
• Die Modulo-Funktion soll Aussagen darüber treffen, ob eine Division mit oder ohne Rest erfolgt ist und anschließend das Ergebnis der Division zum Vergleich als Fließkommawert ausgeben.
• Sorge dafür, dass das Programm so lange läuft, bis der Benutzer es beendet.
  Tipp: Sprungmarke, Goto.
• Achte auf passende Datentypen!

Eine mögliche Lösung findest du hier: shellcalc.ab3

Befehlssequenzen wiederholen

Nehmen wir einmal an, du möchtest fünfzigmal hintereinander einen bestimmten Text ausgeben. Natürlich könntest du dafür fünfzigmal hintereinander eine entsprechende NPrint-Anweisung schreiben – aber das wäre umständlich. Ist aber auch nicht nötig, denn BlitzBasic stellt auch für dieses Problem verschiedene Kontrollstrukturen zur Verfügung, die im Fachjargon Wiederholungsschleifen genannt werden.

Die For … Next Schleife

Ausblick

[Zurück zur Übersicht] | [zurück] | [vowärts]