Einführung in BASIC

Interpreter-BASIC

für Original-IBM-PC/AT: BASIC und (besser) BASICA ("advanced"), für Kompatible GWBASIC. Aufruf des Interpreters (z.B.): BASIC (Will man ein fertiges BASIC-Programm (.BAS) sofort ablaufen lassen, so kann man auch BASIC basicpro aufrufen.) Innerhalb des BASIC-Interpreters (beenden: SYSTEM) kann man im Direktmodus oder im Programmodus arbeiten. (a) Der Direktmodus kann zur Durchführung kleinerer Berechnungen quasi wie ein Taschenrechner benutzt werden. Zur Ausgabe der Ergebnisse benötigt man das Kommando PRINT oder gleichbedeutend ? (Fragezeichen), z.B.:

?4*ATN(1) 3.14159... (pi)

(b) Im Programm-Modus muß jede Zeile mit einer Zeilennummer (0..65535) eingeleitet werden (evtl. automatisch mit AUTO). Programmstart mit RUN, Abbruch mit Strg+Untbr bzw. Strg+C.

Beispiel: Berechnung von Kreisumfang und -fläche.

100 PI=4*ATN(1)
110 INPUT "Radius";R
120 U=2*PI*R
130 F=PI*R*R
140 PRINT "RADIUS=";R
150 PRINT "UMFANG=";U
160 PRINT "FLÄCHE=";F
170 END

Interpreter-BASIC: Steuerbefehle

SYSTEM: beendet BASIC, Rückkehr zu DOS
RUN: oder F2; startet das BASIC-Programm (Abbruch: Strg+C)
LIST: oder F1; gibt die BASIC-Programmliste aus
LIST von-bis: Liste von Zeile ... bis Zeile ...
LLIST: Ausdrucken der BASIC-Programmliste
LOAD "...": oder F3; lädt ein BASIC-Programm
SAVE "...": oder F4; speichert das BASIC-Programm (kodiert!)
SAVE "...",A: speichert das BASIC-Programm als Klartext
MERGE "...": Zuladen eines BASIC-Programms (nur Klartext)
EDIT nr: editiere Zeile nr
DELETE von-bis: lösche von Zeile ... bis Zeile ...
NEW: löscht das BASIC-Programm
CONT: oder F5; setzt die Programmausführung fort
RENUM: numeriert das BASIC-Programm neu
RENUM neu,alt,step: (neue Zeilennr., alte Zeile, Schrittweite)
AUTO: automatische Generierung von Zeilennummern (Abbruch: Strg+C)
TRON: oder F7; Trace-Modus an (Ausgabe der Zeilennummern)
TROFF: oder F8; Trace-Modus aus

BASIC: wichtigste Befehle

(a) Eingabe (von der Tastatur): INPUT

INPUT A
INPUT A,B,C
INPUT TEXT$
INPUT "Eingabe x,y:",X,Y
INPUT "Radius";R   (das Semikolon erzeugt ein Fragezeichen)

Hinweis: mehrere Variablen bzw. Eingaben werden durch Kommata getrennt.

(b) Ausgabe (auf den Bildschirm): PRINT oder ? (Drucker: LPRINT)

PRINT A
PRINT A,B,C      (das Komma wirkt als Tabulator) 
PRINT TEXT$
PRINT "Radius=";R   (Semikolon: Verknüpfung ohne Tab) 
PRINT "Eingabe:";   (Semikolon am Ende unterdrückt
                     Zeilenvorschub)

REM Hier folgt die Berechnung

(d) Programmunterbrechung: STOP, Programmende: END

(e) Sprunganweisung: GOTO zeilennr.

GOTO 100      (Interpreter-BASIC)
GOTO MARKE    (modernes Compiler-BASIC)
MARKE:

BASIC: math. Standard-Funktionen

SIN(X): Sinus (Argument im Bogenmaß)
COS(X): Cosinus (Argument im Bogenmaß)
TAN(X): Tangens (Argument im Bogenmaß)
ATN(X): Arcus Tangens (im Bogenmaß)
SQR(X): Quadratwurzel
EXP(X): Exponentialfunktion
LOG(X): natürlicher Logarithmus
ABS(X): Absolutbetrag
INT(X): Ganzzahl <= x
SGN(X): Vorzeichen (-1, 0 oder 1)
RND(0): Pseudo-Zufallszahl (0 <= y < 1)

BASIC: arithmet. Operatoren

^: Potenzierung
* /: Multiplikation, Division
+ -: Addition, Subtraktion
\: Ganzzahl-Division ("mit Rest")
MOD: modulo ("Rest" bei der Division)
=: Zuweisung

BASIC: Vergleichsoperatoren

=: gleich
<: kleiner als
>: größer als
<=: kleiner oder gleich
>=: größer oder gleich
<>: ungleich

bedingte Anweisungen

Einfache Anweisungen werden "unbedingt" durchgeführt. Jegliche "intelligente" Programmierung basiert darauf, daß der Programmablauf von der Erfüllung bestimmter Bedingungen abhängig gemacht werden kann. Einfachste Variante:

wenn Bedingung erfüllt dann führe Befehl aus [anderenfalls überspringe diesen Befehl]

BASIC: IF bedingung THEN befehl

Variante mit Alternativentscheidung:

wenn Bedingung erfüllt dann Befehl 1 sonst Befehl 2

BASIC: IF bedingung THEN befehl1 ELSE befehl2

Schleifen

Problem: Bei vielen Aufgabenstellungen ist es erforderlich, daß gewisse Programmteile mehrmals abgearbeitet werden. Prinzipiell (aber ungeschickt und unökonomisch) läßt sich dieses Problem mit "GOTO" und "IF" lösen. Standard-BASIC bietet folgende Möglichkeit (einfachste Variante):

FOR i=i1 TO i2     (Initialisierung und Test)
    anweisungen    (wiederholte Ausführung)
NEXT i             (Schleifenende, Inkrementierung von i)

Erweiterung: wählbare Schrittweite (STEP); auch negativ möglich!

FOR i=i1 TO i2 STEP i3  (Initialisierung und Test)
    anweisungen         (wiederholte Ausführung)
NEXT i                  (Schleifenende, i=i+i3)

WHILE ... WEND -Schleife:

WHILE bedingung    (solange Bedingung erfüllt)
    anweisungen    (wiederholte Ausführung)
WEND               (Schleifenende)

DO ... LOOP UNTIL -Schleife (nur Turbo und Quick BASIC):

DO
   anweisungen         (wiederholte Ausführung)
LOOP UNTIL bedingung   (Prüfung erst am Schleifenende)

Hier erfolgt die Prüfung erst am Schleifenende, die Schleife wird daher mindestens einmal durchlaufen. Sie kann mit EXIT LOOP (Turbo BASIC) bzw. EXIT DO (Quick BASIC) auch vorzeitig verlassen werden.

Felder (Arrays)

Problem: Abspeicherung von Meßdatenreihen, Tabellen, Vektoren und Matrizen (mit "einfachen" Variablen sehr umständlich, nicht effizient programmierbar). Lösung: Felder , deren Elemente über einen Index (oder mehrere Indizes) ansprechbar sind. Beispiel: A(I), A ist der Feldname, I der Index.

Dimensionierung von Feldern

Felder müssen im allgemeinen dimensioniert werden. Das ist erforderlich, um den benötigten Speicherplatz zu reservieren sowie (bei mehrdimensionalen Feldern) um die Elementposition aus den Indexangaben berechnen zu können:

DIM A(100),B(30),C(3,3),D(4,4,3)

Die Indizierung beginnt üblicherweise bei Null, das Feld A(100) enthält also 101 Elemente; das Feld C(3,3) enthält 4x4 = 16 Elemente.

Achtung: Die Dimensionierung von Feldern (Arrays) ist in allen höheren Programmiersprachen erforderlich. In BASIC gibt es davon eine Ausnahme: DIM X(10) ist "automatisch" vorgegeben ("default"), d.h., Felder mit maximalem Index 10 brauchen nicht unbedingt deklariert zu werden (man sollte es aber dennoch tun!).

Initialisierung von Variablen

Nach dem Programmstart (RUN) werden in BASIC alle Variablen automatisch auf Null gesetzt. Dasselbe erreicht man durch den BASIC-Befehl CLEAR. Achtung: CLEAR löscht alle Variablen und die Dimensionierungen der Felder!

Zuweisung von Konstanten

(a) umständlich:

A = 1.23
B = 2.34
C = 3.14

(b) eleganter mit DATA und READ:

DATA 1.23,2.34,3.14
READ A,B,C

(mit RESTORE kann die DATA-Anweisung zurückgesetzt werden)

Definition neuer Funktionen

DEF FNname(x) = ...     (Definition) 
y = FNname(z)           (Aufruf)

Beispiel:

DEF FNLG(X)=LOG(X)/LOG(10)    (dekadischer Logarithmus) 
Y=FNLG(2)                     => 0.30103

(Der Funktionsname muß mit FN beginnen!)

Unterprogramme

dienen zur Strukturierung des Programms, indem sie bestimmte Teilaufgaben übernehmen (z.B. Diagonalisierung einer Matrix, Erstellen eines Diagramms). Sie sind besonders dann nützlich, wenn sie mehrmals aufgerufen werden, weil die Programmierung nur einmal erfolgt.

Interpreter-BASIC bietet nur eine eingeschränkte Möglichkeit zum Arbeiten mit Unterprogrammen: GOSUB ... RETURN.

 100 anweisung
 110 GOSUB 2000    (Verzweigung ins Unterprogramm)
 120 anweisung     (hierher erfolgt die Rückkehr)
 ... ...
1000 END
2000 anweisung     (Beginn des Unterprogramms)
2010 anweisung
 ... ...
2100 RETURN        (Ende des Unterprogramms,
                    Rückkehr ins Hauptprogramm)

Der Aufruf eines Unterprogramms erfolgt mit GOSUB zeilennummer. Es gibt keinen speziellen Startbefehl für das Unterprogramm. Das Unterprogramm wird mit RETURN beendet; dabei erfolgt ein Rücksprung ins Hauptprogramm, es geht weiter mit der Anweisung, die auf "GOSUB" folgt. Achtung: In dieser Art Unterprogramm sind alle Variablen global, haben also denselben Wert wie im Hauptprogramm!

Arbeiten mit Dateien

Um Daten von einer Diskette oder Festplatte lesen zu können (bzw. um Daten zu schreiben), muß die betreffende Datei zunächst geöffnet (ggf. zuvor neu angelegt) werden.

OPEN: öffnen
CLOSE: schließen
INPUT: lesen
LINE INPUT: Zeile lesen
PRINT: schreiben
WRITE: schreiben

Jeder Datei wird beim Öffnen eine Kanal-Nummer zugewiesen (ähnlich wie in FORTRAN). Geöffnete Dateien müssen nach Abschluß der Lese-/Schreiboperationen wieder geschlossen werden. Achtung: Wenn ein Programm "unsanft" verlassen wird (insbesondere durch Ausschalten des Gerätes, Notausstieg mit Strg+C oder Alt+Strg+Entf), so kann das zu Fehlern im Dateisystem führen (=> CHKDSK), wenn Dateien zum Schreiben geöffnet waren!

Im (PC-Interpreter-)BASIC gibt es vier verschiedene Modi der Dateibearbeitung, die beim Öffnen festgelegt werden müssen:

OUTPUT: nur Ausgabe; alter Dateiinhalt (falls vorhanden) geht verloren!
APPEND: nur Ausgabe; Anhängen an bereits vorhandene Daten
INPUT: nur Eingabe (Lesen)
RANDOM -: Lese- und Schreibzugriffe möglich (Organisation in "Records" und Datenfelder)

(a) Lesen von einer Datei:

OPEN "scratch.dat" FOR INPUT AS #1    (Kanal Nr. 1)
INPUT #1, X   (analog zur Eingabe von der Tastatur)
INPUT #1, Y
LINE INPUT #1, TEXT$
         (liest eine ganze Zeile, auch mit Kommata)
CLOSE #1

(b) Schreiben auf eine Datei:

OPEN "scratch.dat" FOR OUTPUT AS #3   (Kanal Nr. 3)
PRINT #3, X
PRINT #3, TEXT$
CLOSE #3

Unterschied zwischen PRINT und WRITE:

PRINT #3, 1,2,3      => 1       2       3
WRITE #3, 1,2,3      => 1,2,3

Bei WRITE werden die Ausgabedaten innerhalb einer Zeile durch Kommata getrennt, so daß sie mit INPUT ordnungsgemäß wieder eingelesen werden können. (Bei BASIC dient das Komma als Listentrennzeichen von Eingabefeldern, in Pascal oder C hingegen ein Leerzeichen!)

Das Arbeiten mit "RANDOM"-Dateien ist komplizierter. Die Datei ist in Datensätze (RECORDS) mit definierter Länge unterteilt, die durchnumeriert sind (ab Null). FIELD legt das Datensatz-Format fest, GET bzw. PUT (in Verbindung mit LSET oder RSET) liest bzw. schreibt einen Datensatz.

Turbo-BASIC, Quick BASIC

Aufruf: TB bzw. QBASIC

Hauptmenü (Turbo-BASIC)

(ggf. erreichbar mit ESC): File (Datei-Operationen: Load, New, Save, Write to, Main file, Directory, Change dir, OS shell, Quit), Edit (Editor), Run (Programmstart), Compile (ggf. Erstellung einer .EXE-Datei), Options (Compiler-Optionen), Setup (diverse Einstellungen, z.B. Farben), Window (Darstellungsart der vier Fenster), Debug (TRON/TROFF).

F1 bietet Hilfe zu den einzelnen Menüpunkten.

Alt+X oder ESC File Quit beendet Turbo Basic.

Besonderheiten von Turbo Basic (Power Basic, Quick Basic)

Hierbei handelt es sich um modernes Compiler-BASIC mit Pascal-ähnlichen Sprachelementen. Hinweis: Auch Interpreter-Basic-Programme können (i.allg.) ohne Änderungen mit TB oder QB compiliert werden. Hierfür muß das Basic-Programm unbedingt als ASCII-Datei vorliegen (SAVE "PROG",A). Zeilennummern sind in TB bzw. QB nicht notwendig, aber erlaubt. Beim Arbeiten ohne Zeilennummern müssen die Befehle GOTO und GOSUB (die man hier allerdings besser vermeidet) mit einer Sprungmarke versehen werden:

GOTO marke
   
marke:
   anweisungen

Sprungmarken, mit angehängtem Doppelpunkt (:) versehen, müssen einzeln auf einer Zeile stehen.

Der Zahlentyp "double precision" (variable#) entspricht hier dem IEEE-Standard (im Gegensatz zum Interpreter-Basic).

Blockstrukturen

Programmblöcke, z.B. bedingte Anweisungen (IF ... THEN ... ELSE) oder Schleifen, bestehen häufig aus mehreren Einzelanweisungen. Die Programmierung mehrzeiliger Blöcke wird von TB, PB und QB unterstützt in:

bedingten Anweisungen: IF ... THEN ... ELSE ... END IF
Auswahlblöcken: SELECT CASE ... CASE ... END SELECT
Schleifen: DO ... LOOP
Unterprogrammen: SUB ... END SUB
Funktionen: DEF FNfct() ... END DEF

Block-IF

IF bedingung THEN   '    THEN steht am Zeilenende! 
   anweisungen
   
ELSEIF bedingung2 THEN   '    ELSEIF ist ein Wort! 
   anweisungen
   
ELSE   '    wenn alles andere nicht zutraf 
   anweisungen
   
END IF   '    END IF sind zwei Wörter!

Die Blöcke ELSEIF (ggf. mehrere) und ELSE (logischerweise nach allen ELSEIFs) sind optional. Beachte die unterschiedliche Schreibweise von ELSEIF und END IF. Die Block-IF-Struktur kann ggf. mit EXIT IF vorzeitig verlassen werden.

Auswahl-Block (SELECT)

Eine Mehrfachauswahl läßt sich mit Hilfe von IF-Abfragen programmieren. Eleganter arbeitet man aber mit der SELECT-Anweisung (Abfrage von Ganzzahlen oder Zeichenketten):

SELECT CASE var %
  CASE 1   '    IF var %=1 THEN ... 
    anweisungen 
     
  CASE 2:  anweisung    '    IF var %=2 THEN   
  CASE 3:  anweisung    '    IF var %=3 THEN   
  CASE ELSE:  anweisung    '    ELSE ...
END SELECT

(Der Doppelpunkt dient dazu, mehrere Befehle voneinander zu trennen, die auf einer Zeile stehen.)

Schleife (LOOP)

DO
  anweisungen
  IF abbruch THEN EXIT LOOP   '    optional 
  anweisungen
       ...
LOOP UNTIL abbruchbedingung

Die LOOP-Schleife kann vorzeitig mit EXIT LOOP (Quick Basic: EXIT DO) verlassen werden.

Unterprogramme (SUB)

Turbo Basic und Quick Basic erlauben neben der herkömmlichen GOSUB ... RETURN -Konstruktion das Arbeiten mit echten Unterprogrammen (SUB). Echte Unterprogramme benutzen lokale Variablen, die nur innerhalb des Unterprogramms gelten.

Für den Datenaustausch mit dem Hauptprogramm gibt es zwei Möglichkeiten:

(a) Parameter-Übergabe

CALL unterprog(par1,par2,par3)

Im Beispiel gibt es drei Übergabeparameter (par1, par2, par3). Die Regeln entsprechen denen von FORTRAN, so daß Datenaustausch in beiden Richtungen möglich ist (bei Verwendung von Variablennamen); es können auch (Zahlen-)Werte übergeben werden (natürlich nur an das Unterprogramm).

(b) Deklaration "gemeinsamer" Variablen mit SHARED (ähnlich zu COMMON in FORTRAN; das Basic-COMMON funktioniert hier nicht).

Definition von Unterprogrammen:

SUB unterprog(par1,par2,par3)   '    dummy-Parameter 
  SHARED var1,var2,feld()   '    gemeinsame Variablen 
  anweisungen
       ...
  anweisungen
END SUB

Innerhalb des Unterprogramms können die "dummy"-Parameter (Übergabe-Parameter), lokale und gemeinsame Variablen benutzt werden.

Aufruf:

CALL unterprog(Var,Wert,1.234)

Unterprogramme können auch parameterfrei sein (SUB noparam ... END SUB, Aufruf: CALL noparam). Vorteile der "SUB"-Unterprogramme: mit Namen ansprechbar, einfache Werteübergabe [Bsp.: CALL proc(27.3)], Durchführung gleicher Prozeduren mit unterschiedlichen Variablen (auch Feldern!), Vermeidung von Seiteneffekten durch versehentliche Benutzung globaler Variablen.

Vorzeitiges Verlassen von "SUB"-Unterprogrammen ist mit EXIT SUB möglich.

Block-Funktionen

Definition:

DEF FNxyz(par1,par2,par3)
  anweisungen
      ...
  FNxyz = ausdruck   '    Wert-Zuweisung! 
      ...
END DEF

Der Funktion muß einmal ein Wert zugewiesen werden! Mit EXIT DEF kann die Funktionsdefinition vorzeitig verlassen werden.

Aufruf:

y = FNxyz(p1,p2,p3)

____________________

Burkhard Kirste; 1993/10/09