dienen zum Erstellen von Anwenderprogrammen. Notwendig für individuelle Problemlösungen. Anmerkung: ``Programmierung'' ist auch mehr oder weniger wichtig in Programmpaketen wie dBase (eigene Programmiersprache!), Excel bzw. Lotus 1-2-3 (Formeln im Kalkulationsblatt; Macros) und sogar in der Textverarbeitung (Word für Windows: Word BASIC für Makros).
unterstes Niveau, direkte Eingabe des Maschinencodes in Zahlenform (``Bit für Bit''). Nachteile: sehr mühselig, unübersichtlich, schlecht zu modifizieren, total maschinenabhängig.
dienen zur komfortableren Erstellung von Programmen in
Maschinensprache. Anstelle des numerischen Programmcodes werden
die Befehle als Text, als ``mnemonischer'' Code eingegeben
(Bsp.: MOV, ADD, SUB, JMP, JSR, RET).
Assembler-Programme sind übersichtlicher und leichter zu
modifizieren als die Maschinensprache selbst. Vorteile:
Assembler-Programme benötigen wenig Speicherplatz und arbeiten
mit der höchstmöglichen Geschwindigkeit. Nachteile: total
abhängig vom verwendeten Prozessor (der CPU), langwierige und
schwierige Programmierarbeit, da jeder Programmschritt einzeln
eingegeben werden muß. (Mit einem Makro lassen sich Gruppen von
Programmschritten zusammenfassen.)
sind (mehr oder weniger) problemorientiert. Sie bieten mächtigere Befehle und Funktionen, die -zig Programmzeilen in einem Assemblerprogramm entsprechen würden. Vorteile: sie sind relativ schnell erlernbar und führen (bei einfachen Problemen) schnell zum Ziel, sie sind (nahezu) maschinenunabhängig (portabel). Vielfach werden Hilfen bei der Programmerstellung und bei der Fehlersuche geboten. Nachteil: Programmcode und Ausführungszeiten sind länger als bei Assemblerprogrammen. Besonders langsam sind ``interpretierte'' Programme (wie Interpreter-BASIC).
FORTRAN (FORmula TRANslator), BASIC (Beginners' All-purpose Symbolic Instruction Code), PASCAL (benannt nach dem franz. Mathematiker Blaise Pascal, entwickelt von Niklaus Wirth), C (entwickelt von Kernighan & Ritchie aus ``B'').
Weitere (hier nur erwähnt): ADA (im militärischen Bereich), ALGOL (ähnlich zu PASCAL, nicht mehr aktuell), APL (Mathematik; Matrix- und Vektorrechnung), ASYST (ähnlich zu FORTH; entwickelt zur Erfassung und Verarbeitung von Meßdaten), COBOL (COmmon Business Oriented Language; im Bürobereich), FORTH (stapelorientiert, ``UPN'' wie bei HP-Taschenrechnern, einfache Erstellung eigener Befehle), LISP (ältere Sprache für Expertensysteme), MODULA-2 (strikt modularer Aufbau, sonst PASCAL-ähnlich), PL/1, Oberon (Nachfolger von Pascal bzw. Modula), Prolog (für Expertensysteme, ``künstliche Intelligenz''), Smalltalk (objektorientierte Sprache), ...
wissenschaftliche Programmiersprache mit langer Tradition und sehr umfangreichen Programmsammlungen. Anwendung auf rein numerische Probleme einfach und übersichtlich, aber wenig geeignet für raffinierte Programmkonstruktionen oder für Textmanipulationen. Weiterer Nachteil: Herkunft aus dem ``Lochkarten-Zeitalter''; jede Programmzeile besteht aus 80 Spalten, wobei der eigentliche Programmtext auf den Spalten 7-72 stehen muß. (FORTRAN IV = FORTRAN 66, FORTRAN V = FORTRAN 77; neu: FORTRAN 90)
Auf den meisten Heim- und Personalcomputern verfügbar, leicht zu lernen und leicht zu benutzen. Meist als ``interpretierte'' Sprache vorhanden, d.h., die Befehle werden unmittelbar ausgeführt, ohne daß zuvor eine Umwandlung in ein Maschinenprogramm erfolgt. Vorteil dieses Verfahrens: geringere Anforderung an die Leistungsfähigkeit des Computers und sehr schnelle Möglichkeit für Programmänderungen; Nachteil: Programmausführung (sehr) langsam. Es gibt jedoch auch ``Compiler'' für BASIC (Quick BASIC, Power BASIC, Visual BASIC), die ein BASIC-Programm in Maschinensprache umwandeln und somit ``schnelle'' Programme erzeugen. Es gibt viele BASIC-Dialekte; alte BASIC-Interpreter erfordern Zeilennummern und bieten wenig Möglichkeiten zur übersichtlichen, ``strukturierten'' Programmierung. Diese Nachteile sind z.B. bei Quick BASIC und bei Turbo BASIC (Power BASIC) weitgehend ausgemerzt. Fazit: Moderne BASIC-Varianten sind für wissenschaftliche Programmieraufgaben kleineren und mittleren Umfangs gut geeignet, sie führen dabei meist schneller ans Ziel als andere Programmiersprachen. Für umfangreiche, komplizierte Aufgabenstellungen wie z.B. quantenmechanische Rechnungen (außer vielleicht HMO) sollte BASIC aber nicht in Betracht gezogen werden.
unterstützt das Prinzip der ``strukturierten Programmierung'', neue Befehle lassen sich in Form von Prozeduren (Unterprogrammen) leicht erstellen. Alle verwendeten Variablen müssen (im Gegensatz zu BASIC oder FORTRAN) vorher ``deklariert'' werden. PASCAL ist verhältnismäßig leicht erlernbar. Turbo-Pascal bzw. Borland-Pascal (auf PCs) ist berühmt für seine Schnelligkeit (bei der Compilation und der Programmausführung). Neue Versionen gestatten auch objektorientiertes Programmieren. Nachteile: begrenzte mathematische Möglichkeiten (z.B. ist die Potenzierung nicht vordefiniert!), wenig geeignet für sehr umfangreiche Projekte.
Unterstützt das Prinzip der ``strukturierten Programmierung'' ähnlich wie PASCAL, ist aber erheblich leistungsfähiger und erlaubt auch eine sehr maschinennahe Programmierung. C ist für die Programmierung sehr umfangreicher und komplexer Probleme bestens geeignet. Die Variante C++ erlaubt objektorientierte Programmierung. Nachteilig ist, daß C schwerer zu erlernen ist als etwa PASCAL und daß C-Programme schwer ``lesbar'' sind; Programmierfehler können leicht zum ``Absturz'' des Programms und sogar des Systems führen. Fazit: C ist eine Programmiersprache für Profis.
Die Erstellung eines Anwendungsprogramms erfolgt prinzipiell in folgenden Schritten: Problemanalyse und Aufstellung eines Programmablaufplans, Umsetzung in eine Programmiersprache (Codierung), Übersetzung in ein ausführbares Programm (s.u.), schließlich Testen des Programms und ggf. Fehlerbeseitigung (``debugging'', Behebung syntaktischer und logischer Fehler). Als Programmierer erstellt man ein Programm im Klartext, den Quellcode, der erst in das ausführbare Programm übersetzt werden muß. Hierzu sind mehrere Schritte notwendig:
Interpreter: interpretierte Programme sind nicht als solche lauffähig, sondern müssen über den Interpreter (z.B. BASIC) aufgerufen werden.
Computer können letzten Endes nur die Zustände ``aus'' oder ``ein'' voneinander unterscheiden. Unterscheidung zwischen genau zwei verschiedenen Möglichkeiten wie ``aus'' oder ``ein'' bzw. ``0'' oder ``1'' ist nun die kleinste Informationseinheit, die man als ein Bit bezeichnet. Mit Hilfe der Ziffern 0 und 1 läßt sich ein Zahlensystem analog zum Dezimalsystem aufbauen, in dem prinzipiell auch alle Zahlen darstellbar sind. Wie bei den Dezimalzahlen arbeitet man mit einem Positionssystem, wobei aber jede Stelle nicht eine Zehnerpotenz, sondern eine Zweierpotenz bedeutet. Außer dem Dezimal- und dem Dual-System sind auch noch das Oktal- (Basis 8) und das Hexadezimalsystem (Basis 16) von Bedeutung.
Dezimal Dual Oktal Hexadezimal (Basis 10) (Basis 2) (Basis 8) (Basis 16)
0 0 0 0
1 1 1 1
2 10 2 2
3 11 3 3
4 100 4 4
5 101 5 5
6 110 6 6
7 111 7 7
8 1000 10 8
9 1001 11 9
10 1010 12 A
11 1011 13 B
12 1100 14 C
13 1101 15 D
14 1110 16 E
15 1111 17 F
16 10000 20 10
1 Bit: 0 ... 1, kleinste Informationseinheit; 1 Byte = 8 bit: 0 ... 255, also 2^8 Möglichkeiten; 1 KB = 2^10 Byte = 1024 Byte (!). Ein Byte speichert einen Buchstaben (26 kleine, 26 große, dazu Umlaute, 10 Ziffern, Sonderzeichen etc.). 1 Computerwort: je nach Maschine 8, 16, 32 oder 64 Bit.
1 DIN A4-Seite (eng bedruckt): 60 Zeilen mit je 60 Zeichen, enthält also 3600 Zeichen oder 3600 Byte. 1 Diskette (DS/DD) faßt 360 KB (also 100 DIN A4-Seiten), 1 Diskette (HD) faßt 1.2 bzw. 1.44 MB (also 330 bzw. 400 DIN A4-Seiten), 1 (kleine) Festplatte faßt 200 MB (also 55000 DIN A4-Seiten), 1 CD-ROM faßt über 500 MB (also 140000 DIN A4-Seiten).
Ganzzahlen mit 2 Byte = 16 Bit, Bereich -32768...32767
Lange Ganzzahlen mit 4 Byte = 32 Bit, Bereich -2147483648...2147483647
Fließkommazahlen (im IEEE-Standard) mit 4 Byte = 32 Bit, Bereich (+-)1.2*10^-38...(+-)3.4*10^38, Genauigkeit etwa 8 Dezimalstellen
Doppelt genaue Fließkommazahlen mit 8 Byte = 64 Bit, Bereich (+-)2.23*10^-308...(+-)1.79*10^308, Genauigkeit etwa 16 Dezimalstellen
(Fließkommazahlen werden intern als Mantisse + Exponent im Dualsystem gespeichert.)
Zeichen (Buchstaben, Ziffern, Sonderzeichen), Zeichenketten (Text), Ganzzahlen (integer), Fließkommazahlen (real), logische Größen (``wahr'' oder ``unwahr'') sowie zusammengesetzte Datentypen (Datum, Zeit; Verbunde, Strukturen).
BASIC FORTRAN PASCAL C
Zeichen A$ character*1 char char Zeichenkette A$ character*(*) string[ ] char * Ganzzahl A% integer*2 integer int Lange Ganzzahl A& integer*4 longint long Fließkommazahl A! real*4 single float doppelt genau A# real*8 double double logisch -- logical boolean --
Ein Programmablaufschema läßt sich besonders übersichtlich in Form eines Flußdiagramms darstellen.
( START )
/ Eingabe /
| Rechenvorschrift |
/ Ausgabe (Druck) /
< Abfrage: Weiter? >
( STOP )
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 "FLAECHE=";F 170 END
SYSTEM beendet BASIC, Rückkehr zu DOS RUN F2 startet das BASIC-Programm (Abbruch: Strg+C) LIST F1 gibt die BASIC-Programmliste aus LIST von-bis Liste von Zeile ... bis Zeile LLIST Ausdrucken der BASIC-Programmliste LOAD ``...'' F3 lädt ein BASIC-Programm SAVE ``...'' 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 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 F7 Trace-Modus an (Ausgabe der Zeilennummern) TROFF F8 Trace-Modus aus
(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: Verknuepfung ohne Tab)
PRINT "Eingabe:"; ' (Semikolon am Ende unterdrueckt Zeilenvorschub)
(c) Kommentare: REM oder ' (Apostroph),
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. Anm. _______________________________________________________________ SIN(X) sin x Sinus (Argument im Bogenmaß) COS(X) cos x Cosinus (Argument im Bogenmaß) TAN(X) tan x Tangens (Argument im Bogenmaß) ATN(X) arctan x Arcus Tangens (im Bogenmaß) SQR(X) sqrt x Quadratwurzel EXP(X) e^x Exponentialfunktion LOG(X) ln x natürlicher Logarithmus ABS(X) |x| Absolutbetrag INT(X) Ganzzahl <= x SGN(X) Vorzeichen (-1, 0 oder 1) RND(1) Pseudo-Zufallszahl (0 <= y < 1)
^ Potenzierung * / Multiplikation, Division + - Addition, Subtraktion \ Ganzzahl-Division (``mit Rest'') MOD modulo (``Rest'' bei der Division) = Zuweisung
= gleich < kleiner als > größer als <= kleiner oder gleich >= größer oder gleich <> ungleich
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
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 Ausfuehrung)
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 Ausfuehrung)
NEXT i ' (Schleifenende, i=i+i3)
WHILE ... WEND -Schleife:
WHILE <bedingung> ' (solange Bedingung erfuellt)
<anweisungen> ' (wiederholte Ausfuehrung)
WEND ' (Schleifenende)
DO ... LOOP UNTIL -Schleife (nur Turbo und Quick BASIC):
DO
<anweisungen> ' (wiederholte Ausfuehrung)
LOOP UNTIL <bedingung> ' (Pruefung erst am Schleifenende)
Hier erfolgt die Prüfung erst am Schleifenende, die Schleife wird daher mindestens einmal durchlaufen. Sie kann mit EXIT DO (Quick BASIC) bzw. EXIT LOOP (Turbo BASIC) auch vorzeitig verlassen werden.
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.
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 4 * 4 = 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!).
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!
(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)
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!)
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 Rueckkehr)
... ...
1000 END
2000 <anweisung> ' (Beginn des Unterprogramms)
2010 <anweisung>
... ...
RETURN ' (Ende des Unterprogramms, Rueckkehr 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!
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.
Datei-Operation BASIC-Befehl
öffnen OPEN
schließen CLOSE
lesen INPUT
LINE INPUT
schreiben PRINT
WRITE
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 Datenfeldern)
(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.
Aufruf: QBASIC bzw. TB.
(erreichbar mit der Maus oder mit Alt)
Datei: Neu, Öffnen, Speichern, Speichern unter, Drucken, Beenden
Bearbeiten: Ausschneiden, Kopieren, Einfügen, Löschen, Neue SUB, Neue FUNCTION
Ansicht: SUBs, Aufteilen, Ausgabebildschirm
Suchen: Suchen, Weitersuchen, Ändern
Ausführen: Start, Neustart, Weiter
Debug: Einzelschritt, Prozedurschritt, Rückverfolgung ein, Haltepunkt ein/aus, Alle Haltepunkte löschen, Nächste Anweisung festlegen
Optionen: Bildschirmanzeige, Pfad für Hilfe, Syntax überprüfen
Hilfe: Index, Inhalt, Thema, Verwenden von Hilfe, Info
Tastaturkommandos: F1: Hilfe zu Schlüsselwort, Shift-F1: Hilfe allgemein, F2: SUBs, F3: Weitersuchen, F4: Ausgabebildschirm, F5: Ausführen/Weiter, Shift-F5: Ausführen/Start, F6: Fenster, F7: Bis zum Cursor ausführen, F8: Einzelschritt, F9: Haltepunkt, F10: Prozedurschritt, Alt: Menü, Esc: Abbruch, Shift-Entf: Ausschneiden, Strg-Einfg: Kopieren, Shift-Einfg: Einfügen, Entf: Löschen, Strg-Y: Zeile löschen
Hierbei handelt es sich um modernes Compiler-BASIC mit Pascal-ähnlichen Sprachelementen. Hinweis: Auch Interpreter-Basic-Programme können (i.allg.) ohne Änderungen mit QBASIC oder TB compiliert werden. Hierfür muß das Basic-Programm unbedingt als ASCII-Datei vorliegen (SAVE ``PROG'',A). Zeilennummern sind in QBASIC bzw. TB 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).
Programmblöcke, z.B. bedingte Anweisungen (IF ... THEN ... ELSE) oder Schleifen, bestehen häufig aus mehreren Einzelanweisungen. Die Programmierung mehrzeiliger Blöcke wird von QBASIC, PB und TB unterstützt in:
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 Woerter!
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.
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.)
DO
<anweisungen>
IF <abbruch> THEN EXIT DO ' optional
<anweisungen>
LOOP UNTIL <abbruchbedingung>
Die LOOP-Schleife kann vorzeitig mit EXIT DO (Quick Basic; Turbo Basic: EXIT LOOP) verlassen werden.
Quick Basic und Turbo 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).
Definition von Unterprogrammen:
SUB unterprog(par1,par2,par3) ' dummy-Parameter
SHARED var1,var2,feld() ' gemeinsame Variablen
<anweisunge>
...
<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)
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.
Definition (QBASIC):
FUNCTION xyz(par1,par2,par3)
<anweisungen>
xyz = ausdruck ' Wert-Zuweisung!
END FUNCTION
Der Funktion muß einmal ein Wert zugewiesen werden! Mit EXIT FUNCTION kann die Funktionsdefinition vorzeitig verlassen werden.
Aufruf:
y = xyz(p1,p2,p3)
Aufruf: TURBO.
Beispiel-Pascal-Programm mit Erläuterung:
PROGRAM test; {Beginn des PROGRAMms}
VAR {alle Variablen muessen deklariert werden}
eingabe : String; {`eingabe' ist eine Zeichenkette}
i,j,k : Integer; {i,j,k sind Ganzzahl-Variablen}
BEGIN {BEGINn des Befehlsblocks}
Readln(eingabe); {lies eine Zeile von der Konsole}
Writeln('Ihr Text:',eingabe); {gib eine Zeile aus}
Write('Geben Sie 2 Summanden ein:');
Readln(i,j);
k := i+j;
Writeln('Summe:',k);
Readln;
END. {ENDe des Programms}
Anmerkungen:
K. Ebert, H. Ederer: ``Computeranwendungen in der Chemie'', VCH, Weinheim 1983; 2. Auflage 1985. (Beispiele in Interpreter-BASIC)
M. D. Johnston, Jr.: ``Computational Chemistry'', Elsevier, Amsterdam 1988. (Beispiele in Interpreter und Quick BASIC)
P. C. Jurs: ``Computer Software Applications in Chemistry'', Wiley, New York 1986. (Beispiele in FORTRAN)
W. H. Press, B. P. Flannery, S. A. Teukolsky, W. T. Vetterling: ``Numerical Recipes'', Cambridge University Press, Cambridge 1986. (Umfangreiche Programmsammlung für Standardprobleme der numerischen Mathematik. Versionen für FORTRAN, PASCAL oder C erhältlich)
J. Hückstädt: ``Programmieren mit Turbo-Basic'', Markt & Technik, Haar bei München, 1987
W. Kassera, V. Kassera: ``Programmieren mit Turbo-Pascal 5.5'', Markt & Technik, Haar bei München, 1989