Die Basis zum Basic, Teil 2: Programmverzweigungen und Schleifenkonstrukte

Über sechs Stufen steigen Sie mit uns vom Computeranwender zum Programmierer auf.

Stefan Ems, Arne Wieczorrek

Diesmal lassen wir die trockene Theorie hinter uns und wenden uns gleich der Programmierung zu. Darum frisch drauf los! Sollten Sie zu den ungeduldigen »Praktikern« gehören und bereits über Grundkenntnisse im Basic-Programmieren verfügen, so können Sie sich direkt mit dem Programm-listing »RECHNER.BAS« befassen. In diesem Basic-Programm, einem simplen Rechner für die vier Grundrechenarten, finden viele Befehle Verwendung, die wir im vorliegenden Kursabschnitt ausführlich erläutern. Übrigens: In diesem Kursteil beschränken wir uns auf »normale«, also auf nicht-Omikron-spezifische Basic-Befehle und Funktionen.

»RECHNER.BAS« besteht aus dem Hauptprogramm mit zwei ineinander verschachtelten Schleifen (Zeile 100 bis 370) sowie den fünf Unterprogrammen »Add«, »Sub«, »Mul«, »Div« und »Erg«. Das Hauptprogramm ruft die Unterprogramme zum Rechnen unter Berücksichtigung Ihrer Eingabe (Zeile 280) über eine »ON... GOSUB«-Anweisung (Zeile 29Q) auf.

Jede der vier Rechen-Routinen verzweigt ihrerseits über einen »GOSUB«-Befehl in die Ausgabe-Routine »Erg« (Zeile 540 bis 560), die das Ergebnis der Rechnung auf dem Bildschirm ausgibt.

Na, haben Sie das Listing schon abgetippt? Sicherlich, denn besonders umfangreich ist es ja nicht. Doch jetzt nicht zu ungestüm! Schon manche Abtipp-Stunde war vergebens, weil der ungeduldige Programmierer sein »Opus« sofort ausprobierte, ohne das Programm zuvor gesichert zu haben.

Wenn Sie nämlich den Omikron-Basic-Interpreter verlassen (oder er Sie wegen eines simplen Tippfehlers mit einem »Absturz« verläßt), so entschwindet das Programm unwiederbringlich aus dem Computerspeicher und ist für immer verloren. Dieses betrübliche Ereignis ist beim vorliegenden Listing nicht zu erwarten. Beherzigen Sie dennoch immer die wichtigste Grundregel des Programmierers: Vor dem ersten Testlauf das Programm unbedingt auf einem externen Datenspeicher (Diskette oder Festplatte) sichern. Wie das geht, lesen Sie im Kasten »Speichern, laden, laufenlassen«.

Sollte der Computer Ihnen beim anschließenden Test tatsächlich den Gehorsam verweigern, läßt sich das fehlerhafte Programm nach Neustart des ST wieder laden.

Im Listing von »RECHNER.BAS« finden Sie in einigen Programmzeilen (zum Beispiel in Zeile 110) einen Doppelpunkt mit nachfolgender »REM«-Anweisung. Der Ausdruck »REM« informiert den Basic-Interpreter darüber, daß sich jetzt ein Kommentar (engl. REMark bedeutet Bemerkung) anschließt, den er bei seiner Übersetzungsarbeit außer acht lassen soll. Befehle, die dem »REM«-Befehl direkt folgen, also nicht durch eine neue Zeile oder einem Doppelpunkt getrennt sind, ignoriert der Interpreter. Der »REM«-Ausdruck läßt sich auch durch ein Hochkomma »’« ersetzen. Diesen »REM-Ersatz« müssen Sie nicht einmal durch einen Doppelpunkt von der zu dokumentierenden Anweisung trennen.

REM Kleiner Taschenrechner 
REPEAT : REM Anfang von Schleife 1 
    Frage$=""
    WHILE Frage$<>"n": REM Anfang von Schleife 2 
        CLS : REM löscht Bildschirm 
        PRINT "Zahl 1:";
        INPUT Z1! : REM Postfix ! bedeutet Fließkommazahl
        PRINT "Zahl 2:";
        INPUT Z2!
        PRINT
        PRINT "Menü:"
        PRINT : REM druckt eine Leerzeile 
        PRINT "1...Zahlen addieren"
        PRINT "2...Zahlen subtrahieren"
        PRINT "3...Zahlen multiplizieren"
        PRINT "4...Zahlen dividieren"
        PRINT
        PRINT "Bitte Zahl eingeben ";
        INPUT A
        ON A GOSUB Add,Sub,Mul,Div 
        PRINT "Weiter J/N ";
        Frage$= INPUT$(1) : REM zuletzt eingegebenes Zeichen nach Frage$.
    WEND : REM Ende von Schleife 2 
    PRINT : PRINT
    PRINT "Wollen Sie wirklich aufhören? J/N ";
    Frage$= INPUT$(1) : REM zuletzt eingegebenes Zeichen nach Frage$.
UNTIL Frage$="j" : REM Ende Schleife 1 
END 
-Add
Ergebnis!=Z1!+Z2!
GOSUB Erg : REM Unterprogramme können verschachtelt werden 
RETURN 
-Sub
Ergebnis!=Z1!-Z2!
GOSUB Erg 
RETURN 
-Mul
Ergebnis!=Z1!*Z2!
GOSUB Erg 
RETURN 
-Div
Ergebnis!=Z1!/Z2!
GOSUB Erg 
RETURN 
-Erg
PRINT "Ergebnis: "?Ergebnis!
RETURN

Der Taschenrechner RECHNER.BAS besteht aus einem Hauptprogramm und fünf Unterprogrammen

Doch kommen wir nun zu Programmverzweigungen und Programmschleifen. Die Programme, die wir bis jetzt gemeinsam durchgearbeitet haben (unseren Basic-Rechner müssen wir ja noch erkunden), führt Omikron-Basic systematisch in der Reihenfolge der Zeilennummern vom Anfang bis zum Ende aus. In der Fachsprache wird dieses Verfahren »linearer Algorithmus« genannt. Das Programmende ist durch den »END«-Befehl gekennzeichnet.

Das heißt jedoch nicht, daß hinter diesem Befehl keine Programmzeilen stehen dürfen. »END« bezeichnet lediglich das Ende des Hauptprogrammes, Unterprogramme wie Prozeduren und Funktionen, die uns noch später beschäftigen werden, finden ihren Platz im Programmlisting erst nach dem »END«. Stößt der Interpreter auf diesen Befehl, so bricht er seine Tätigkeit ab. Bei folgendem Mini-Programm gibt der ST das »Zu spät« aus Zeile 30 nicht mehr auf dem Bildschirm aus, da der Interpreter die Arbeit mit Erreichen der Zeile 20 beendet:

10 PRINT "Anfang"
20 END
30 PRINT "Zu spät!"

Linear strukturierte Programme sind in der Programmierpraxis kaum von Bedeutung. Fast alle Programme benutzen Programmteile mehrfach oder verzweigen in Unterprogramme, abhängig von bestimmten Faktoren oder von Ergebnissen des Programmlaufes. Die Ablaufsteuerung derartiger Programme übernehmen Sprungbefehle, Entscheidungs-Anweisungen, Schleifenkonstrukte und die spezifische Verwaltung von Unterprogramm-Aufrufen.

Beginnen wir mit den Sprungbefehlen, den einfachsten Kontrollstrukturen zur Beeinflussung des Programmablaufes. Basic verfügt über zwei verschiedene Sprungbefehle, nämlich »GOTO« und »GOSUB«. Mit dem »GOTO«-Befehl springen Sie auf eine beliebige Programmzeile. »GOTO« setzen Sie in Zusammenhang mit einer Zeilennummer ein oder mit einer Zeichenkette als Sprungmarke, dem sogenannten Label (»GOTO < Zeilennummer >« oder »GOTO < Label > «). Omikron-Basic unterstützt beide Verfahren. In der angesprungenen Zeile steht der Befehl, den der Interpreter als nächsten bearbeitet. Das Label kennzeichnet eine bestimmte Position in der Reihenfolge der Programmanweisungen. Im Gegensatz zur Sprungmarke < Zeilennummer > ist ein Label unabhängig von der Numerierung der Programmzeilen.

Im Unterschied zu »GOTO« verlangt der »GOSUB«-Befehl, der eine ähnliche Syntax besitzt, einen speziellen Aufbau der angesprungenen Programmteile. Mit »GOSUB« rufen Sie nämlich Unterprogramme auf. Jedes Unterprogramm, auch Teilalgorithmus genannt, stellt einen in sich abgeschlossenen Teil des Gesamtprogrammes dar. Es muß mit einer »RETURN«-Anweisung abgeschlossen sein.

Sorgen Sie in Ihren Programmen stets dafür, daß der Interpreter nie ohne »GOSUB«-Befehl in ein Unterprogramm hineinläuft. »Flicken« Sie die Unterprogramme also nicht irgendwo mitten in das Hauptprogramm ein, sondern trennen Sie diese Unterroutinen durch einen »END«-Befehl ab. Stößt der Interpreter auf eine »RETURN«-Anweisung, ohne durch ein »GOSUB« in den entsprechenden Programmbereich geschickt worden zu sein, so beschwert er sich mit der Fehlermeldung »RETURN WITHOUT GOSUB ERROR«.

Dieses Verhalten wird verständlich, wenn man sich klarmacht, in welcher Weise der Interpreter die Befehlskonstruktion »GOSUB«... »RETURN« verwaltet. Bei jeder »GOSUB«-Anweisung merkt sich Omikron-Basic die »Absprung«-Position, legt die Information auf einen sogenannten Stapel und springt auf die erste Anweisung des Unterprogrammes. Ruft das erste Unterprogramm seinerseits über »GOSUB« ein weiteres Unterprogramm auf, so legt der Interpreter die Information über die zweite Absprung-Position zuoberst auf den Stapel und springt in das zweite Unterprogramm.

Haben Sie korrekt programmiert, findet der Interpreter die erste »RETURN«-Anweisung am Ende des Unterprogrammes 2. Daraufhin nimmt er die oberste Information vom Stapel und springt dem gefundenen Wert entsprechend zurück. Dann fährt er in der Programmbearbeitung unmittelbar hinter der Position fort, von der aus er das Unterprogramm mit »GOSUB < Zeilennummer >« oder »GOSUB < Labelname >« aufgerufen hatte. Beim nächsten »RETURN« geht er genauso vor.

Ohne Unterprogrammaufruf gibt es natürlich auch keinen Eintrag im Stapel, und der Interpreter weiß nicht, wohin er bei der Interpretation einer »RETURN«-Anweisung zurückspringen soll. Folglich beschwert er sich frustriert bei Ihnen.

Eine moderne Programmiersprache wie Omikron-Basic bietet neben den altbekannten Unterprogramm- und Verzweigungskonstrukten wesentlich leistungsfähigere Elemente: die Definition von Prozeduren und Funktionen. Diese erlauben es dem Programmierer, auf »GOSUB«- und »GOTO«-Anweisungen völlig zu verzichten. Wir werden auf die beiden mächtigen Programmstrukturen in Teil 4 unseres Kurses genauer eingehen. Hier nur eine kurze Einführung in die Programmierung von Prozeduren.

Im Gegensatz zu »GOSUB... RETURN«-Unterprogrammen besitzen Prozeduren einen Prozedur-Kopf, der das Unterprogramm mit einem frei wählbaren Namen verknüpft:

100 DEF PROC ST_Mag 
110 PRINT "ST-Magazin"
120 RETURN

Wie beim »GOSUB«-Unterprogramm signalisiert die »RETURN«-Anweisung das Prozedur-Ende. Unsere kleine Beispiel-Prozedur gibt den Schriftzug »ST-Magazin« auf dem Bildschirm aus. Zum Aufrufen der Prozedur brauchen Sie lediglich den Prozedur-Namen in eine Programmzeile zu schreiben, und schon erscheint »ST-Magazin« auf Ihrem Bildschirm:

10 ST_Mag 
20 END
100 DEF PROC ST_Mag 
110 PRINT "ST-Magazin"
120 RETURN

Die »END«-Anweisung in Zeile 20 ist besonders wichtig. Der Interpreter reagiert »ausgesprochen sauer«, wenn Sie ihn während des Programmlaufes Prozeduren übersetzen lassen. Dies hat er nämlich bereits bei der Definition erledigt. Geben Sie im Bildschirmeditor den Begriff »ST_Mag« als Direkt-Befehl ein (also ohne Zeilennummer), so schreibt Omikron-Basic »ST-Magazin« auf den Bildschirm. Durch die Eingabe der Zeilen 100 bis 120 hat der Interpreter einen neuen Befehl »gelernt«, der wie ein Standardbefehl zu benutzen ist.

SAVE "Rechner"
SAVE "RECHNER"
SAVE "rechner.bas"
SAVE "RECHNER.BAS"

In Anbetracht der vielfältigen Fähigkeiten der Omikron-Basic-Prozeduren und -Funktionen sollten Sie künftig auf »GOTO«-Programmsprünge völlig verzichten. Eine sinnvolle Anwendung des »GOSUB«-Befehls sehen wir lediglich in Verbindung mit der »ON«-Anweisung zur Steuerung von Menü-Auswahlen (siehe Zeilen 280 und 290 im Listing »RECHNER.BAS«). Hinter »ON« muß eine Zahlenvariable stehen, die mittels einer Eingabe-Anweisung mit Werten belegt wird. Danach folgt die »GOSUB«-Anweisung und eine durch Kommata getrennte Liste von Zeilennummern oder Label der anzuspringenden Unterprogramme.

Erhält die Variable den Wert 1, so verzweigt der Interpreter entsprechend der Angabe im ersten Listenelement, bei Wert 2 entsprechend Listenelement 2, und so weiter. Findet der Interpreter für den Variablenwert kein passendes Element, so fährt er mit der nächsten Anweisung nach »ON... GOSUB« fort.

Eine weitere Form in sich abgeschlossener Programmbereiche stellen die sogenannten Schleifen dar. Schleifen wiederholen einen durch Schleifenanfang und -ende eingeschlossenen Programmteil so oft, bis eine sogenannte Abbruchbedingung erfüllt ist. Zur Erläuterung der verschiedenen Schleifenkonstrukte im Omikron-Basic nehmen wir uns folgende Aufgabe vor: Der Computer soll die ganzen Zahlen von eins bis hundert und deren Quadrat ausdrucken.

Eine Lösung ohne Schleifen-Programmierung wäre nach diesem Muster vorstellbar:

10 PRINT 1,1 "2 : REM ^2 bedeutet > >hoch 2< <
20 PRINT 2,2 ^2 
30 PRINT 3,3 ^2
1000 PRINT 100,100 ^2

Zweifellos eine sehr umständliche Methode! Besonders ärgerlich, daß Sie hier hundertmal die gleiche Rechenvorschrift programmieren und lediglich die Zahlen variieren. Mit einer Schleifenkonstruktion läßt sich das Problem wesentlich eleganter und vor allem flexibler lösen. Wie jedes Standard-Basic verfügt auch der Omikron-Interpreter über die »FOR... NEXT«-Schleife. Sie verlangt folgende Syntax:

FOR < Zählvariable > = < Startwert > TO <Endwert> [STEP <Schrittweite>] : <Befehle> : NEXT [< Zählvariable >]

Bei der Befehls-Syntax verwenden wir folgende Schreibweise: Reservierte Basic-Wörter wie Anweisungen und Befehle schreiben wir in Großbuchstaben. Die Zeichen < und > zeigen an, daß die eingeschlossenen Parameter variabel sind. Abschnitte, die von eckigen Klammern eingeschlossenen sind, können Sie auslassen. Die vollständige Syntaxbeschreibung aller Befehle finden Sie im Omikron-Basic-Handbuch auf den Seiten 165 ff.

Mit dieser Schleife lösen wir unser Problem folgendermaßen: »Zähle die Variable I von 1 bis 100 und drucke dabei ständig den Inhalt der Variable I und ihr Quadrat!«. Die »FOR... NEXT«-Schleife erhöht (oder erniedrigt) den Zähler I automatisch und vergleicht seinen jeweiligen Wert mit der Endbedingung der Schleife. Sie wird daher auch Zählschleife genannt.

10 FOR I=1 TO 100 
20 PRINT I,I ^2 
30 NEXT

Bild 2 zeigt das zugehörige Flußdiagramm. Die Zählvariable der »FOR... NEXT«-Schleife enthält beim ersten Schleifendurchlauf den Startwert, hier also 1. Nach Abarbeitung der Befehlsreihe und Erreichen der »NEXT«-Anweisung erhöht sich die Zählvariable automatisch um die Schrittweite (ohne Angabe von »STEP« ist die Schrittweite gleich 1), das Programm springt zur Zeile mit der »FOR«-Anweisung zurück. Dieser Vorgang läuft solange ab, bis die Zählvariable den Endwert erreicht hat. Sind Start- und Endwert identisch, so wird die »FOR«-Schleife genau ein Mal durchlaufen. Ist der Startwert größer als der Endwert, wird die Schleife kein einziges Mal abgearbeitet. Zum Rückwärtszählen muß der Startwert größer sein als der Endwert, der »STEP«-Befehl mit negativer Schrittweite ist in jedem Fall erforderlich, also auch bei der negativen Schrittweite »-1«.

Als Start- und Endwert sowie als Schrittweite dienen konstante Zahlen oder Zahlenvariable. Wie alle Variablen sind auch diese Werte vom Programm veränderbar, sogar innerhalb der »FOR ... NEXT«-Schleife. Doch Vorsicht bei Beeinflussung der Zählvariablen durch die Befehle in der Schleife: Solche Veränderungen sind wenig sinnvoll!

10 FOR I=1 TO 100 
20 PRINT I,I^2
30 I=I-1: REM Vorsicht! Zählvariable wird verändert.
40	REM Endbedingung (I=100) ist nicht erreichbar 
50 NEXT

Als Ergebnis erhalten Sie eine sogenannte Endlosschleife, aus der Ihr ST in treuer, aber stumpfsinniger Pflichterfüllung keinen Ausweg findet. Helfen Sie ihm durch gleichzeitiges Betätigen der Tasten Control und C.

Nachdem Sie diesen ersten Schleifen-»Klimmzug« »verdaut« haben, sind die »REPEAT.. .UNTIL«- und die »WHILE... WEND«-Schleife schnell erklärt. »REPEAT« kennzeichnet den Schleifenanfang. Es folgt eine beliebige Befehlsreihe. Das Ende der Schleife markiert »UNTIL« mit einer Bedingung. »REPEAT ... UNTIL« hat also die gleiche klammernde Funktion wie »FOR... NEXT«. Die von »REPE AT... UNTIL« eingeschlossenen Befehle werden so oft wiederholt, bis die Bedingung hinter »UNTIL« erfüllt ist (engl. repeat until = wiederhole bis).

10 REPEAT 
20 I=I+1
30 PRINT I,I	^2
40 UNTIL I=100

Bild 1 zeigt das Flußdiagramm. Eine Bedingung in Basic hat stets folgende Syntax:

< Variabie1 > < Operator> < Variable2 >

Als Operatoren finden alle mathematischen logischen Operatoren Anwendung. Variable 2 ist durch eine Konstante ersetzbar.

Im Gegensatz zur »FOR... NEXT«-Schleife verändert eine »REPEAT... UNTIL«-Schleife die Abbruchvariable in der »UNTIL«-Bedingung nicht selbsttätig. Daher müssen die Programmzeilen in der Schleife dafür sorgen, daß sich die Abbruchvariable verändert. In unserem Fall lautet die Abbruchbedingung »I = 100«. Zeile 20 erhöht die Zählvariable I mit der Anweisung »I = I + 1« bei jedem Schleifendurchlauf um den Betrag 1. Die Festlegung eines Startwertes für I ist nicht nötig, da Basic bei Programmstart allen Zahlenvariablen den Wert 0 zuweist.

Die »REPEAT.. .UNTIL«-Schleife stellt nicht grundsätzlich eine Zählschleife dar. Also benötigt sie auch keine Zählvariable. Die Abbruchbedingung kann zum Beispiel auch aus einem Vergleich von Zeichenkettenvariablen resultieren. So läßt sich eine Tastaturabfrage so oft wiederholen, bis eine Taste gedrückt wird:

10 REPEAT ' Schleifenanfang
20  A$=INPUT$(1) ' Diese Anweisung ordnet A$ das zuletzt auf der 
30  ' Tastatur gedrückte Zeichen zu.
40 UNTIL A$< > "" ' Bedeutet: Bis A$ ungleich leere Menge. Dies 
50 ' entspricht: Bis A$ ein Zeichen enthält.
60 PRINT "Es wurde ein ";A$;" Zeichen gedrückt."

Sehr ähnlich arbeitet die »WHILE ... WEND«-Schleife. Hier steht die Abbruchbedingung hinter »WHILE« am Schleifenanfang:

10 WHILE I<100 
20 I=I+1 
30 PRINT I,I^2 
40 WEND

Das Flußdiagramm sehen Sie in Bild 3. Da der Interpreter die Bedingung bereits überprüft, bevor er die Schleife zum ersten Mal durchläuft, bearbeitet er die Befehle zwischen »WHILE« und »WEND« kein einziges Mal, wenn die Bedingung nicht erfüllt ist. Die »REPEAT«-Schleife dagegen läuft mindestens ein Mal durch, bevor Sie die Endbedingung kontrolliert.

Schleifen lassen sich auch ineinander verschachteln. Achten Sie darauf, daß die äußere Schleife die innere vollständig umklammert:

10 FOR I=1 TO 10    'Anfang Schleife 1 
20  FOR X=1 TO I     'Anfang Schleife 2 
30      PRINT X;" ";
40  NEXT X 'Ende Schleife 2 
50  PRINT
60 NEXT I 'Ende Schleife 1

Überprüfen Sie Ihre Erkenntnisse anhand dieses Beispieles. Formulieren Sie das Ergebnis eines Programmlaufes in Worten, bevor Sie das Programm in der Praxis ablaufen lassen. Kontrollieren Sie Ihre Voraussage durch einen realen Programmlauf. Alles richtig? Na also!

Soviel über Schleifenkonstrukte, Programmverzweigungen und Unterprogramme. In Kursteil 3 setzen wir uns mit der »bedingten Befehlausführung« auseinander. Als Etappenziel haben wir ein kleines Datenfernübertragungsprogramm (DFÜ-Programm) für Sie vorbereitet. Bis zum nächsten Mal!

(W. Fastenrath/ps)