Previous Next Contents

3. Programmiersprachen und Grundlagen der Programmierung

3.1 Programmiersprachen

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).

Klassifizierung

Maschinensprache:

unterstes Niveau, direkte Eingabe des Maschinencodes in Zahlenform (``Bit für Bit''). Nachteile: sehr mühselig, unübersichtlich, schlecht zu modifizieren, total maschinenabhängig.

Assembler (Makro-Assembler):

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.)

Höhere Programmiersprachen:

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).

Wichtige höhere Programmiersprachen (für Naturwissenschaftler)

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), ...

FORTRAN:

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)

BASIC:

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.

PASCAL:

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.

C:

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.

3.2 Grundlagen der Programmierung

Vom Quellcode zum ausführbaren Programm

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:

  1. Compiler: Quellcode -> Assemblerprogramm
  2. Assembler: Assemblerprogramm -> Objektcode
  3. Linker: Objektcode (+ Libraries) -> ausführbares Programm

Interpreter: interpretierte Programme sind nicht als solche lauffähig, sondern müssen über den Interpreter (z.B. BASIC) aufgerufen werden.

Zahlensysteme, Informationseinheiten

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.

Zahlensysteme

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.

Speicherkapazitäten

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).

interne Zahlendarstellung

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.)

Datentypen

Zeichen (Buchstaben, Ziffern, Sonderzeichen), Zeichenketten (Text), Ganzzahlen (integer), Fließkommazahlen (real), logische Größen (``wahr'' oder ``unwahr'') sowie zusammengesetzte Datentypen (Datum, Zeit; Verbunde, Strukturen).

Variablentypen

                   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     --

Flußdiagramm

Ein Programmablaufschema läßt sich besonders übersichtlich in Form eines Flußdiagramms darstellen.

( START )

/ Eingabe /

| Rechenvorschrift |

/ Ausgabe (Druck) /

< Abfrage: Weiter? >

( STOP )

3.3 Programmieren 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 "FLAECHE=";F
170 END

Interpreter-BASIC: Steuerbefehle

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

3.4 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: 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. Standard-Funktionen

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)

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 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.

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 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!).

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 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!

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.

BASIC: Arbeiten mit Dateien

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.

3.5 Quick BASIC, Turbo-BASIC

Aufruf: QBASIC bzw. TB.

Hauptmenü von Quick BASIC und Tastaturkommandos

(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

Besonderheiten von Quick Basic (Power Basic, Turbo 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 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).

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 QBASIC, PB und TB unterstützt in:

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 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.

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 DO  ' optional
                <anweisungen>
        LOOP UNTIL <abbruchbedingung>

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

Unterprogramme (SUB)

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.

Block-Funktionen

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)

3.6 Turbo-Pascal

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:

  1. Alle Variablen müssen in Pascal deklariert werden.
  2. Jeder Befehl endet mit einem Semikolon (;).
  3. Das Zuweisungszeichen ist :=
  4. Zeichenketten werden von Apostrophs ('...') eingeschlossen (nicht von Anführungszeichen!)
  5. Jeder Block (Gruppe von Befehlen) wird zwischen BEGIN und END eingeschlossen.
  6. Dem letzten END folgt ein Punkt (END.)
  7. Kommentare stehen zwischen { geschweiften Klammern }
  8. Groß- und Kleinschreibung werden nicht unterschieden (außer innerhalb von Zeichenketten).

3.7 Literaturhinweise zum Programmieren

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


Previous Next Contents