Das folgende Tutorial stammt ursprünglich von „Wirthi (Wirthi's

Document Sample
Das folgende Tutorial stammt ursprünglich von „Wirthi (Wirthi's Powered By Docstoc
					                            EINFÜHRUNG IN TURBO-PASCAL                                       Dieses Tutorial zeigt ihnen nur den richtigen Weg. Lesen Sie ein Kapitel, machen Sie die
                                                                                             Beispielprogramme. Experimentieren Sie! Sie werden schnell ein Gefühl für die Sprache
                                                                                             bekommen. Dann können Sie sich die unterstützende Literatur besorgen: die Hilfe ihres
Es soll noch einmal betont werden, dass es zum Verständnis eines
                                                                                             Compilers ist immer ein guter Tipp. Außerdem gibt es im Netz genug andere Seiten, die
Programmierparadigmas ausreicht, eine einzige, allerdings einigermaßen repräsentative
                                                                                             fortgeschrittene Themen behandeln. Oder sie steigen gleich auf eine andere (bessere ???)
Programmiersprache (z.B. PASCAL, aber nicht BASIC) zu erlernen. Der Umstieg auf eine
                                                                                             Programmiersprache um.
andere Programmiersprache, die demselben Paradigma gehorcht, erfordert dann kein
Erlernen neuer Konzepte.
                                                                                             Benutzungsbedingungen
                                                                                             Dieses Tutorial ist für den privaten Gebrauch gedacht. Es darf kostenlos (für private
Das folgende Tutorial stammt ursprünglich von „Wirthi“ (Wirthi’s Pascal Tutorial)
                                                                                             Zwecke sowie zum Zweck der Schulbildung) gelesen, gespeichert und weitergegeben
                                                                                             werden, jedoch darf dabei nichts verändert werden! Eine kommerzielle Nutzung ohne
Ziele dieses Tutorials
                                                                                             meine Zustimmung ist allerdings untersagt. Wenn Sie einen Link auf mein Tutorial setzten
Dieses Tutorial soll Ihnen Grundkenntnisse in Pascal beibringen. Sie lernen einfache
                                                                                             wollen, so ist das natürlich erlaubt. Allerdings würde ich Sie bitten, den Link auf meine
Programme zu schreiben, diese zu kompilieren und zu verbessern. Es ist jedoch keine
                                                                                             Homepage (und nicht auf das Tutorial) zu setzen, da es andernfalls Probleme mit der
umfassende Pascal-Referenz. Ich gehe nicht auf Profi-Konzepte ein, wie z.B. die Objekt-
                                                                                             Navigation geben könnte. Wenn möglich, teilen Sie mir auch bitte mit wo sich der Link
orientierte Programmierung, die Turbo Pascal bietet.
                                                                                             befindet.
                                                                                                                                    Allgemeines
Welche Vorkenntnisse sollten Sie haben?
                                                                                             Pascal wurde ca. 1971 an der ETH Zürich von Nikolaus Wirth entwickelt. Sie wird vor
Sie sollten mit Ihrem Betriebssystem umgehen können (Anwendungen starten, Editor
                                                                                             allem als Lehrsprache in Schulen genutzt, da sie leicht erlernbar ist, aber im Gegensatz zu
bedienen, Dateien verwalten, etc). Kenntnisse einer anderen Programmiersprache sind
                                                                                             BASIC strukturiertes Programmieren unterstützt. Aber auch in Unternehmen wird Pascal
zwar vorteilhaft, aber nicht notwendig.
                                                                                             eingesetzt, speziell in der weiterentwickelten Windows-Version „Delphi“ von Inprise
                                                                                             (http://www.inprise.com, ehemals Borland).
Welche Software benötigen Sie?
Sie benötigen nichts weiter als einen Text-Editor und einen Pascal-Compiler (mit einigen
                                                                                                                                     Geschichte
Zusatzprogrammen z.B. Linker). Da jedoch alle im Tutorial gemachten Angaben
                                                                                              1971   Nikolaus Wirth entwickelt Pascal.
(Beispielprogramme, Syntax, etc) von Borland Turbo-Pascal 5.5 bzw. 7.0 stammen,
sollten Sie am besten dieses Programmpaket benutzen. Anderenfalls müssten Sie ihre            1977   UCSD Pascal wird an der "University of California San Diego" entwickelt,
Programme geringfügig ändern. Außerdem bekommen Sie mit der Turbo-IDE eine                           speziell für " Kleinrechner" (z.B. Apple).
leistungsstarke Entwicklungsumgebung mitgeliefert, und Sie brauchen sich nicht mit            1983   Turbo-Pascal (Borland), eine weit verbreitete Version.
Kommandozeilenparametern herumquälen.                                                         199?   Delphi (Borland), eine Windows-Programmiersprache, kommt auf den Markt.
                                                                                                     Delphi ist eng an Pascal angelehnt.
Anderenfalls rate ich ihnen, Free-Pascal (http://www.brain.uni-freiburg.de/~klaus/fpc/) zu
benutzen. Dies ist ein sehr leistungsfähiger Compiler; er unterscheidet sich jedoch                                     Aufbau von Pascal-Programmen
geringfügig von Turbo-Pascal.                                                                Ein normales Pascal-Programm besteht aus folgenden Teilen: Programmkopf,
                                                                                             Deklarationsteil, Anweisungsteil.
Welche Hardware benötigen Sie?
                                                                                             Programmkopf
Keine spezielle, solange Sie einen Compiler ausführen können. Theoretisch reicht ein         Hier wird der "Name" des Programms bekannt gegeben; dies hat auf das eigentliche
Taschenrechner, der Pascal versteht ... Ein 386'er reicht vollkommen aus, je schneller der   Programm keine Auswirkung und kann daher in TURBO entfallen.
Rechner, desto schneller wird alles laufen ...
                                                                                             Deklarationsteil
Und nach dem Tutorial?                                                                       Hier werden Variablen vereinbart, Typen definiert und „Units“ eingebunden. Mehr dazu
                                                                                             später.

                                                                                                                                                                                      1
Anweisungsteil                                                                                                       Variablen, Datentypen, Zuweisungen
Hier steht der eigentliche Programm-Code. Der Anweisungsteil besteht wiederum aus          Variablen
zwei Teilen:                                                                               Eine Variable ist ein Synonym für eine Speicherstelle in einem Computer. Einfacher
                                                                                           gesagt, eine Variable bietet Raum, um Daten (z.B. eine Zahl) zu speichern. Dieser Raum
            Deklarationsteil der Unterprogramme (Funktionen und Prozeduren);               wird im Hauptspeicher des Computers (RAM) angelegt.
                                  Hauptprogramm
Im Deklarationsteil der Unterprogramme werden, wie der Name andeutet, die                  Datentypen
Unterprogramme definiert. Mehr zu Unterprogrammen später. Das Hauptprogramm                Der Datentyp einer Variablen gibt an, welche Art an Daten eine Variable enthalten kann.
beginnt (wie jeder Code-Block) mit "BEGIN" und endet mit "END". An das end                 So ist es zum Beispiel möglich, in eine Variablen vom Typ integer eine Zahlen zwischen
anschließend wird noch ein Punkt gesetzt, um dem Compiler mitzuteilen, dass der            ca. -32000 und +32000 zu speichern. In einer char-Variable können Sie hingegen alle
Programmcode hier zu Ende ist.                                                             möglichen ASCII-Zeichen speichern (alles, was Sie mit der Tastatur erzeugen können und
                                                                                           noch etwas mehr).
pa_1_1.pas
                                                                                           Ganze Zahlen: integer, word, byte
Program Mein_erstes_Programm;                  (*     Diese     Zeile      ist     der     In Variablen dieses Types können Sie ganze Zahlen abspeichern, also z.B. 1, 2, 100,
Programmkopf *)                                                                            12345. Sie unterscheiden sich jedoch hinsichtlich ihres Wertebereiches:

Var zahl: integer; (* Deklarationsteil *)                                                      •    integer geht von ca. -32000 bis +32000 (Größe 2 Byte);
                                                                                               •    word akzeptiert Werte von 0 bis ca. +65000 (Größe 2 Byte);
Begin (* ab hier Anweisungsteil *)                                                             •    byte hingegen nur Werte von 0 bis +255 (Größe 1 Byte);
  writeln ('Test');
  writeln ('Noch ein Test');                                                               Gleitkommazahlen: real
End. (* Anweisungsteil Ende *)                                                             In einer real-Variablen können Kommazahlen gespeichert werden, z.B. 3.141592654. Der
                                                                                           Wertebereich reicht von 2.9 * (10^-39) bis 1.7 * (10^38). Dieser Datentyp reicht also für
Nachdem Sie das Programm eingetippt haben, muss es der Compiler in ein ausführbares        die meisten Kommazahlen. Werden noch höhere Genauigkeiten benötigt, kommen die
Programm übersetzen (in eine *.EXE Datei). Dazu wählen Sie, wenn Sie mit Turbo-Pascal      Datentypen single, double und extended zum Einsatz. Diese werden aber in diesem
arbeiten, im Menu „Start“ den Eintrag „Ausführen“. Wenn Sie ein gültiges Programm          Tutorial nicht besprochen.
eingegeben haben (ohne Fehler), wird dieses zuerst neu übersetzt (kompiliert) und
anschließend ausgeführt.                                                                   Zeichen: char
Einige Hinweise zu diesem Programm (und zu PASCAL allgemein):                              In einer char-Variablen können Sie ein ASCII-Zeichen abspeichern, also ein mit der
Sie werden am Bildschirm das Ausgabe-Fenster nur kurz sehen, da das Ausgabe-Fenster        Tastatur erzeugbares Zeichen (Buchstabe, Ziffer, Sonderzeichen, aber auch z.B. 'ENTER',
geschlossen wird, sobald das Programm beendet ist. Wollen Sie sich die Ausgabe(n)          'SPACE' und 'TAB'). Dabei darf man eines nicht vergessen: man kann in einer char-
ansehen, drücken Sie in der IDE einmal [ALT]+[F5]. Pascal ist nicht case-sensitive, d.h.   Variable '1' abspeichern, das ist jedoch nicht gleichbedeutend mit der Zahl 1, sondern
es unterscheidet nicht zwischen Groß- und Kleinschreibung. Anstatt "PROGRAM" hätten        einfach ein Zeichen, das zufällig eine Ähnlichkeit mit der Ziffer 1 hat! Man kann daher
Sie genauso program oder PrOgRaM schreiben können.                                         nicht (direkt) mit CHAR-Variablen mathematisch rechnen!
         Der Programm-Name (im Beispiel "Mein_erstes_Programm") muss ein Wort sein
(also anstatt [SPACE] einfach _ verwenden) und darf keine Sonderzeichen enthalten. Dies    (Zur Erklärung: char ist nichts anderes als eine Variable vom Typ byte. Der Compiler
gilt auch für alle anderen „Bezeichner“ (Unterprogramm-Namen, Variablen-Namen, etc.).      interpretiert diese Speicherstelle jedoch als ASCII-Zeichen. '1' hat den ASCII-Code 49,
Nach jeder Anweisung, Vereinbarung, etc. muss ein Strichpunkt gemacht werden, bis auf      also ist in der byte-Variablen der Wert 49 gespeichert. Greifen auf die char-Variable zu, so
einige wenige Ausnahmen (am Programmende gehört statt dessen ein Punkt, nach "Begin"       erkennt der Compiler dies und liefert Ihnen das ASCII-Zeichen mit der Nummer der byte-
und vor "End" benötigt man keinen Strichpunkt, vor "else" darf man keinen setzen).         Variablen. Das Konvertieren der char-Variablen in eine Zahl (von '1' nach 49) lernen Sie
                                                                                           später noch kennen)

                                                                                                                                                                                     2
Zeichenketten: string                                                                       PROGRAM Variablen_Test;
In einem String (engl. Kette) kann man Zeichenketten abspeichern. Eine Zeichenkette ist
gleichbedeutend mit mehreren hintereinandergefügten char-Zeichen. Damit kann man z.B.       VAR Zeichen: char;
Wörter oder Sätze darstellen.                                                                   Zahl1,Zahl2:integer;
                                                                                              .......
Logische Werte: boolean
Variablen dieses Types können nur zwei Werte annehmen: true und false. Dabei handelt        Hinweise:
es sich um logische (boolesche) Werte. Man kann damit logische Vergleiche machen, wie          • In einer Zeile können auch mehrere Variablen gleichen Types vereinbart werden,
folgendes Programm verdeutlichen soll:                                                              wenn man einen Beistrich dazwischen setzt.
                                                                                               • Mit einer var-Anweisung können mehrere Variablen, auch von unterschiedlichen
pa_2_1.pas                                                                                          Datentypen, deklariert werden, wie das Beispiel zeigt.

PROGRAM boolescher_Vergleich;                                                               Zuweisungen
                                                                                            Im Anweisungsteil kann man einer Variable nun Werte zuweisen. Dazu schreibt man
VAR test: boolean;                                                                          zuerst den Variablen-Namen, einen Doppelpunkt, ein Gleichheitszeichen und
     z1,z2: integer;                                                                        anschließend den zuzuweisenden Wert.
BEGIN
  z1    := 4;                                                                               pa_2_2.pas
  z2    := z1;
  test := (z1=z2);                                                                          PROGRAM Zuweisung;
  z2    := 5;
  test := (z1=z2);                                                                          VAR Zahl1,     Zahl2, Zahl3: integer;
END.                                                                                        BEGIN
                                                                                              Zahl1 :=     3;
Beschreibung:                                                                                 Zahl2 :=     5;
    • z1 und z2 wird der selbe Wert zugewiesen.                                               Zahl3 :=     Zahl1+Zahl2;
    • test := (z1=z2); Hier wird der "Wahrheitswert" des Klammerausdruckes                    Zahl3 :=     Zahl3*(Zahl1-1);
        berechnet und anschließend der Variablen test zugeordnet. Das Ergebnis ist          END.
    • in diesem Fall "true", da der Ausdruck z1=z2 richtig ist (wahr, "true"). Siehe auch
        weiter unten Vergleiche von Variablen.                                              Was macht das Program:
    • Nun wird z2 der Wert 5 zugewiesen, d.h. sie ist nicht mehr gleich wie z1.                • Zuerst werden 3 Variablen angelegt (Zahl1, Zahl2, Zahl3).
    • Beim folgenden Vergleich ist das Ergebnis "false", da z1 nicht gleich z2 ist.            • Zahl1 wird der Wert 3 zugewiesen.
        "false" wird in test abgespeichert.                                                    • Zahl2 wird der Wert 5 zugewiesen.
                                                                                               • Dieser Ausdruck ist etwas komplexer. Zuerst werden Zahl1 und Zahl2 addiert,
Anlegen von Variablen                                                                              anschließend wird die Summe der Variablen Zahl3 zugewiesen (Zahl1 und Zahl2
Um eine Variable zu anzulegen (zu deklarieren), müssen Sie im Deklarationsteil des                 haben noch ihre alten Werte 5 bzw. 3, Zahl3 hat den Wert 3+5, also 8)
Hauptprogramms (oder später einmal vielleicht in dem eines Unterprogramms)                     • Nun wird Zahl3 mit (Zahl1-1) multipliziert, das Ergebnis in Zahl3 abgespeichert.
das reservierte Wort "VAR" schreiben. Danach folgt der Variablen-Name, ein                         Zahl3 hat dann den Wert 8*(3-1), also 16. Hierbei ist zu beachten das Pascal die
Doppelpunkt und dann der Datentyp.                                                                 mathematischen Vorrangregeln beachtet. hätten Sie bei der letzten Multiplikation
                                                                                                   die Klammern weggelassen, so hätte das Ergebnis (fälschlicherweise) 23
                                                                                                   gelautet: 8*3 + 1 = 24 -1 = 23 ! Also immer Klammern setzen !


                                                                                                                                                                                 3
Zuweisungen bei real                                                                      Sie können Variablen gleichen oder ähnlichen Datentyps miteinander vergleichen. Das
Die Zuweisung zu real-Variablen funktioniert gleich wie die zu Integer-Variablen. Der     geschieht mit einem der folgenden Zeichen unter Anwendung normaler
einzige Unterschied ist der zuweisbare Datentyp: einer real-Variablen können              mathematischer Regeln: = ("ist gleich"), <> ("ist nicht gleich"), < ("ist kleiner"), <= ("ist
Kommazahlen und Gleitkommazahlen zugewiesen werden:                                       kleiner oder gleich"), > ("ist größer"), >= ("ist größer oder gleich"). Als
                                                                                          Ergebnis bekommen Sie eine Boolean-Variable.
.....
realVar := 3;                                                                             .....
realVar := 3.1415;                                                                        booleanVariable := Zahl1<=Zahl2;
realVar := 0.31415e2;                                                                     .....
realVar := 123.45E-3;
.....                                                                                     booleanVariable ist dann true, wenn Zahl1 kleiner oder gleich Zahl2 ist.
Erklärung:
    • Bei der ersten Zuweisung gilt 3 auch als Kommazahl. Der Variablen wird der          Konstanten
        Wert 3,0 zugewiesen.                                                              Konstanten im mathematischen Sinne sind unveränderliche Werte. Beispiele hierfür sind
    • Die zweite Zuweisung speichert in realVar den (gerundeten) Wert der Zahl Pi         Pi oder e.
        (3.141592654...).
    • Die dritte und die vierte Zuweisung speichert jeweils eine Gleitkommazahl ab.       In Pascal können Konstanten als Variable angesehen werden, deren Wert nicht verändert
        Wenn Sie sich damit nicht auskennen - keine Angst, es ist nicht notwendig. Es     werden kann. Wenn Sie anstatt von Variablen Konstanten verwenden, ist sichergestellt,
        handelt sich dabei um die Exponentialschreibweise (der Wert in Zeile 3 bedeutet   dass diese ihren Wert zur Laufzeit nicht verändern. Sie können ihren Wert nur im
        z.B.: 0.32415 * 10 hoch 2, also 31.415).                                          Sourcecode verändern. Würden Sie stattdessen Variablen verwenden, könnten Sie
                                                                                          unabsichtlich irgendwann der falschen Variablen einen Wert zuweißen, und schon ist das
Zuweisungen bei char und string                                                           Programm falsch. Wenn Sie einer Konstante einen Wert zuweisen, bekommen Sie beim
Hier müssen Sie den Wert unter einfaches Anführungszeichen setzen:                        Compilieren eine Fehlermeldung, und Sie wissen, dass etwas "nicht stimmt".

.....                                                                                     PROGRAM Konstanten;
charVariable1         :=   'A';                                                           CONST Pi = 3.1415;
charVariable2         :=   '&';                                                                 maxanz = 13;
stringVariable1       :=   'Test';                                                              intConst : integer=123;
stringVariable2       :=   '!"§$%&/()=?QWERTZUIOP';                                       VAR ....
.....
                                                                                          Wie im Beispiel erkennbar, können Konstanten sowohl mit als auch ohne Typ angelegt
Zu beachten ist natürlich dass ein string bis zu 255, ein char jedoch nur 1 Zeichen       werden. Wichtig ist, nicht zu vergessen, dass man Konstanten im Anweisungsteil keinen
aufnehmen kann.                                                                           Wert mehr zuweisen kann, sondern nur bei der Definition der Konstanten. Gibt man
                                                                                          explizit einen Datentyp an, so muss dieser natürlich mit dem angegebenen Wert
Zuweisungen bei BOOLEAN                                                                   kompatibel sein.
Hier geben Sie als Wert einfach TRUE oder FALSE an:
                                                                                                                            Kontrollanweisungen
.....
boolWahr   := TRUE;                                                                       Boolesche Logik
boolFalsch := FALSE;                                                                      Boolean-Variablen können miteinander verknüpft werden. Dies geschieht mit den
.....                                                                                     booleschen Operatoren and (und), or (oder) und not (nicht) (es gibt noch weitere, auf die
                                                                                          ich hier nicht näher eingehe).
Vergleiche
                                                                                                                                                                                     4
....                                                                                      .....
b3:= b1 AND b2;                                                                           if Zahl=0 then begin
....                                                                                                      boolZahlIstNull := TRUE;
                                                                                                          writeln('Zahl ist gleich Null');
Der Wert von b3 ist dann TRUE, wenn b1 und b2 (and) TRUE sind. Ist einer der beiden                       end
(oder auch beide) FALSE, dann ist b3 ebenfalls FALSE.                                     else begin
                                                                                                boolZahlIstNull := FALSE;
....                                                                                            writeln('Zahl ist ungleich Null');
b3:= b1 OR b2;                                                                                  end;
....                                                                                      ....

Der Wert von b3 ist dann TRUE, wenn b1 oder (or) b2 TRUE ist. Ist also einer (oder        Der "begin-end" Block nach "else" wird dann ausgeführt, wenn Zahl=0 false ist, also wenn
beide) TRUE, dann ist auch b3 TRUE, sind beide FALSE, ist auch b3 FALSE.                  Zahl nicht gleich Null ist. Zu beachten ist, dass der Strichpunkt vor dem "else" immer
....                                                                                      wegfallen muss (sonst tritt ein Syntaxfehler auf)!
b1:= NOT b2;
....                                                                                      case - Anweisung
                                                                                          Eine weite Möglichkeit um Bedingungen auszuwerten ist die Case-Anweisung. Sie kommt
Der Wert von b1 ist dann TRUE, wenn der von b2 FALSE ist. Die not Verknüpfung             bevorzugt zum Einsatz, wenn eine Variable mehr als nur 2 mögliche Werte
"dreht den Wert der Variablen um".                                                        haben kann:

if - Abfragen                                                                             ...
Syntax: IF Bedingung THEN Anweisung; [ ELSE Anweisung; ]                                  case intVariable1 of
Mit Hilfe der if-Anweisung kann man Codeteile ausführen lassen, wenn die                   0: writeln('Der Wert der Variablen ist gleich Null');
dazugehörende Bedingung erfüllt ist (wenn sie true ist).                                   1: writeln('Der Wert der Variablen ist gleich Eins');
                                                                                           else writeln('Der Wert der Variablen ist nicht gleich Eins
....                                                                                      oder Null');
if Zahl1=0 then Zahl2:=10;                                                                end;
....                                                                                      ....

Die Anweisung Zahl2:=10 wird nur ausgeführt, wenn Zahl1=0 true ist. Will man in die if-   Die Anweisung wird durch "case", die zu überprüfende Variable und "of" eingeleitet.
Abfrage mehrere Anweisungen einschließen, benötigt man begin und end:                     Anschließend folgt jeweils ein Wert (Zahl bei int oder byte, Zeichen in Hochkomma bei
                                                                                          char; real und string sind in case-Anweisung nicht möglich). Diesem folgt ein
....                                                                                      Doppelpunkt und die auszuführende Anweisung. Mehrere Anweisungen müssen in
if Zahl1>=0 then begin                                                                    "begin" und "end" eingeschlossen werden! Bei der Ausführung nur die Anweisung (der
                 Zahl2:=Zahl2+1;                                                          Block) ausgeführt, dessen Wert gleich ist wie der Wert der Variablen. Wird kein passender
                 Zahl1:=Zahl2;                                                            Wert gefunden, so wird (falls vorhanden), der else Block ausgeführt.
                 end;
....                                                                                      Schleifen
                                                                                          Um Anweisungen mehrmals hintereinander ausführen, benötigt man Schleifen.
Mittels dem in der Syntax angegebenen Teil "ELSE Anweisung" kann man Anweisungen
dann ausführen lassen, wenn die Bedingung FALSE ist:                                      repeat-Schleife
                                                                                          Syntax: REPEAT Anweisung(en) UNTIL Bedingung;


                                                                                                                                                                                 5
Diese Schleife führt die Anweisungen solange durch, bis die Bedingung wahr ist (deutsch:   ....
"WIEDERHOLE Anweisungen BIS Bedingung"). Dabei wird die Schleife mindestens                Zahl2:=0;
einmal durchlaufen. Bei mehreren Anweisungen benötigt hier kein begin und end!             FOR Zahl1:= 1 to 10 DO Zahl2:=Zahl2+Zahl1;
                                                                                           .....
....
Zahl1:=0;                                                                                  In diesem Beispiel wird Zahl2 in jedem Schleifendurchlauf um Zahl1 erhöht. Da Zahl1
REPEAT                                                                                     nacheinander die Werte von 1 bis 10 hat, ist in Zahl2 nach Verlassen der Schleife die
  Zahl1:=Zahl1+1;                                                                          Summe aller Zahlen von 1 bis 10 gespeichert.
UNTIL Zahl1=3;
....                                                                                                                           Ein- und Ausgabe

In diesem Beispiel wird die Schleife 3 mal durchlaufen. Dabei wird die Variable Zahl1      Bildschirm-Ausgabe
jedes Mal um 1 erhöht. Am Ende des 3. Durchlaufes hat die Variabel den Wert                Bisher konnten Sie die Ergebnisse ihrer Programme nicht überprüfen; damit ist jetzt
3, d.h. die Bedingung Zahl1=3 ist TRUE, daher wird die Schleife beendet und die            Schluss. In diesem Kapitel lernen Sie, wie Sie etwas am Bildschirm ausgeben können.
darauffolgende Anweisung ausgeführt.                                                       Der dazu notwendige Befehl ist write. Er gibt die ihm übergebenen Parameter auf dem
                                                                                           Bildschirm aus (außer, Sie haben unter DOS die Standard-Ausgabe auf ein anderes Gerät,
while-Schleife                                                                             z.B. den Drucker eingestellt). write kann beliebig viele Parameter übernehmen. Der
Syntax: WHILE Bedingung DO Anweisung;                                                      Datentyp ist dabei egal, solange er nicht von Ihnen definiert wurde (Siehe Abschnitt "Type
Die while-Schleife wird solange durchlaufen, bis die Bedingung FALSE ist (deutsch:         und Record").
"WÄHREND/SOLANGE Bedingung MACHE Anweisungen"). Die Schleife wird
mindestens Null mal durchlaufen (die Bedingung kann ja gleich zu Beginn false sein). Bei   pa_4_1.pas
mehreren Anweisungen benötigen Sie begin und end!
                                                                                           PROGRAM Hello_world;
....                                                                                       VAR Zahl1;
Zahl1:=0;                                                                                  BEGIN
WHILE Zahl1<3 DO BEGIN                                                                       Zahl1:=1234;
                 Zahl1:=Zahl1+1;                                                             write('Das ist ein Test');
                 Zahl2:=Zahl2*2;                                                             write('Der Wert der Variable Zahl1 ist: ',Zahl1);
                 END;                                                                      END.
.....
                                                                                           Nach der Ausführung sollten Sie am Bildschirm jedoch nur mit viel Phantasie erkennen
In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist   können, was Sie sehen möchten (wenn überhaupt nicht, eine Erinnerung: mit [ALT]-[F5]
die Bedingung false (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3), also wird mit   sehen Sie die Bildschirmausgabe). Erstens sind noch Reste anderer Programme am
dem Befehl nach der Schleife fortgesetzt.                                                  Bildschirm, außerdem schreibt das Programm beide Ausgaben in eine Zeile.
                                                                                                    Wenden wir uns zuerst dem zweiten Fehler zu. write gibt die Parameter dort aus,
for-Schleife                                                                               wo der Bildschirmcursor steht (und setzt diesen nach der Ausgabe ans Ende der Ausgabe).
Syntax: FOR Variable:= Anfangswert TO Endwert DO Anweisung;                                Wollen Sie, dass der Cursor in eine neue Zeile gesetzt wird, müssen Sie den Befehl writeln
Die for-Schleife ist eine Zählschleife. Die angegebene Variable wird am Anfang auf         (abgeleitet von "write" + "line", line bedeutet "Zeile") benutzen. Dieser funktioniert genau
Anfangswert gesetzt. Danach wird sie nach jedem Durchlauf um 1 erhöht. Ist ihr Wert        so wie write, nur wird am Ende der Ausgabe eine neue Zeile begonnen (Für Profis: unter
größer als Endwert, wird die Schleife beendet. Innerhalb des Anweisungsblockes können      DOS werden die beiden ASCII-Zeichen 13 und 10 angehängt; dies sind die Zeichen für
Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht   Wagenrücklauf und Line Feed)
ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie unbedingt begin und
end!
                                                                                                                                                                                     6
....                                                                                         Drucker
writeln('Dies ist eine Zeile.');                                                             Vorausgesetzt, Sie haben einen Drucker installiert, können Sie unter TURBO ganz einfach
write('Dies steht in der nächsten Zeile!');                                                  auf diesen zugreifen (im Textmodus, Grafik ist deutlich komplizierter). Sie müssen
.....                                                                                        lediglich die Unit printer einbinden. Anschließend können Sie mit den bekannten Befehlen
                                                                                             write bzw. writeln auf dem Drucker ausgeben, wenn Sie als
Nun zum zweiten Fehler, den „Programm-Rückständen“ am Bildschirm. Um das zu                  ersten Parameter "lst" (LST) angeben:
verhindern, muss der Bildschirm gelöscht werden. Das geschieht mit dem Befehl clrscr
("clear screen", "lösche Bildschirm"). Um diesen benutzen zu können, müssen Sie jedoch       pa_4_3.pas
erst mit "USES Crt;" die Unit crt "einbinden", da der Befehl clrscr nicht direkt in
Pascal integriert ist, sondern in der Unit CRT definiert wird. Die Erklärung liefert das     PROGRAM Drucker;
folgende Beispiel:                                                                           USES printer;
                                                                                             BEGIN
pa_4_2.pas                                                                                     WRITELN(lst,'1. Zeile auf dem Drucker.');
                                                                                               WRITELN(lst);
PROGRAM Bildschirm_loeschen;                                                                   WRITE(lst,'3. Zeile.');
USES crt;                                                                                    END.
BEGIN
  clrscr;                                                                                    Tastatur-Eingabe
  writeln('Das steht ganz links oben auf einem gelöschten                                    Damit der Benutzer mit dem Computer kommunizieren kann, muss er über die Tastatur
Bildschirm');                                                                                Befehle und Zeichen eingeben können. Auch dafür stellt Pascal Befehle zur Verfügung:
END.                                                                                         read, readln, readkey. Diese werden im folgenden Abschnitt vorgestellt.
                                                                                             read und readln funktionieren gleich wie write(ln) (nur das halt Zeichen
Farbe                                                                                        eingelesen werden anstelle sie auszugeben). Sie müssen lediglich read(ln) und in
Um Ihre Programme attraktiver gestalten zu können, muss Farbe ins Spiel. Das                 Klammer
funktioniert ziemlich einfach. Mit dem Befehl textcolor, der als Parameter eine Zahl         die Variablenliste angeben:
zwischen 0 und 15 erwartet, können Sie die Textfarbe einstellen. Ab der danach folgenden
Ausgabe werden alle Zeichen in der Farbe des Parameters dargestellt. Gleiches gilt für den   ....
Befehl textbackground, nur diesmal für die Farbe des Zeichen-Hintergrundes. Beide            WRITE('Bitte geben Sie eine Zahl ein: ');
benötigen eine eingebundene crt-Unit! Die Werte für die                                      READLN(integerVariable);
Farben können Sie mit Hilfe des Nachfolgenden Beispieles ermitteln:                          WRITE('Geben Sie einen String ein: ');
                                                                                             READLN(stringVariable);
....                                                                                         ....
textcolor(7);
textbackground(1);                                                                           Das Programm gibt eine Eingabeaufforderung aus. Dann erwartet es vom Benutzer, dass
writeln('Dieser Text wird in Weiß (7) auf                                blauem      (1)     er eine Zahl eingibt, die mit [ENTER] bestätigt werden muss. Danach erfolgt wiederum
Hintergrund ausgegeben.');                                                                   eine Aufforderung zur Eingabe, diesmal eines Strings. Diesen kann man nun eingeben und
textbackground(0);                                                                           ebenfalls mit [ENTER] bestätigen. Dabei kann allerdings ein Problem auftreten. Auch
for farbe := 0 to 15 do                                                                      wenn Sie definiert haben, dass ein integer eingelesen werden soll, kann der Benutzer einen
begin                                                                                        String eingeben (er könnte z.B., absichtlich oder unabsichtlich, "1e" eintippen). Da das
  textcolor(farbe);                                                                          Programm mit dieser Eingabe nichts anzufangen weiß (es hat ja eine Zahl erwartet, und
  writeln("Das ist die Farbe Nummer ",farbe);                                                das ist eindeutig keine), liefert es eine Fehlermeldung. Wenn Sie dieses Problem umgehen
end;                                                                                         möchten, ein kleiner Hinweis: lesen Sie immer einen String ein, und konvertieren Sie
.....                                                                                        diesen in einen integer. Dadurch kann das Programm fehler erkennen und dem Benutzer
                                                                                                                                                                                     7
mitteilen, er soll doch einen integer (oder was auch immer als Eingabe gewünscht ist)        eine kurze Zeit auf der Taste. Da der Computer aber ziemlich schnell ist, arbeitet er
eingeben.                                                                                    möglicherweise schon den nächsten readkey-Befehl ab, während Sie noch immer den
                                                                                             Finger auf der Taste haben. Das ist besonders störend, wenn Sie den Befehl als
readkey                                                                                      "Haltepunkt" geplant hätten: der Computer stoppt einfach nicht:
readkey ist eine Funktion (Siehe Kapitel Unterprogramme), die ein char-Zeichen von der
Tastatur einliest. Dazu geben Sie im Programm einfach folgende Zeile an:                     .....
                                                                                             Write('Bitte geben Sie ein Zeichen ein: ');
.....                                                                                        CharVariable := readkey;
charVariable:=readkey;                                                                       writeln(' Danke. Sie haben das Zeichen                          ',charVariable,'
....                                                                                         eingeben');
                                                                                             readkey;
Diese Zeile erwartet die Eingabe eines char-Zeichens. Im Gegensatz zu read(ln) muss man      ......
nach der Eingabe des Zeichens jedoch nicht [ENTER] drücken, um die Eingabe zu
bestätigen. In der Variable charVariable wird das erste Zeichen gespeichert, das auf der     Anstatt beim zweiten readkey zu warten bis Sie eine Taste drücken, wird das Programm
Tastatur eingegeben wird. Eine weitere Möglichkeit der Anwendung von readkey ist es,         einfach fortgesetzt.
wenn Sie einfach "readkey;" als Befehl eingeben. Dann wartet der Computer, bis Sie eine      Nun zur Lösung des Problems: geben Sie den Code "REPEAT readkey; UNTIL
Taste drücken, speichert diese aber nicht ab (siehe auch nächster Abschnitt (Probleme mit    keypressed=FALSE;" zwischen den beiden readkey's an, und der Computer
Eingabe)). ACHTUNG: readkey benötigt die Unit crt!                                           wird schön brav auf Sie warten:
keypressed
Dies ist ebenfalls eine Funktion, die eine Boolean-Variable zurückliefert. Sie gibt          pa_4_4.pas
Bescheid darüber, ob eine Taste gedrückt wurde, die mit read(ln) oder readkey abgerufen
werden kann (zum Verständnis: auf der Tastatur eingegebene Zeichen werden meist nicht        var taste: char;
direkt vom Programm verarbeitet, sondern erst vom Betriebssystem bzw. dem BIOS des           begin
Computers zwischengespeichert. Erst wenn das Programm eingegebene Zeichen                      Write('Bitte geben Sie ein Zeichen ein: ');
"anfordert" (z.B. mittels read), werden die gespeicherten Zeichen an das Programm              taste := readkey;
übergeben. Dies lauft jedoch so schnell ab, dass der Benutzer davon nichts merkt).             writeln(' Danke. Sie haben das Zeichen ',charVariable,'
Ist der Rückgabewert von keypressed true, dann ist ein Zeichen abfragebereit, sonst nicht:   eingeben');
                                                                                               REPEAT readkey; UNTIL keypressed=FALSE;
.....                                                                                          readkey;
while not keypressed do begin                                                                end.
  Zahl1:=Zahl1+1;
  writeln(Zahl1);                                                                            Was macht dieser Code-Teil? Die repeat-Schleife wird solange ausgeführt, bis keypressed
end;                                                                                         den Wert false zurückliefert, d.h. bis keine Taste mehr gedrückt wird. In der Schleife
.......                                                                                      werden eventuell (unnötigerweise) eingegebene Zeichen abgefragt und ins Nirwana
                                                                                             geschickt.
Dieser Programmcode erhöht solange die Variable Zahl1 und gibt diese aus, bis der
Benutzer eine Taste drückt.                                                                                                    Unterprogramme

Probleme mit Eingabe                                                                         Allgemeines zu Unterprogrammen
Wenn Sie mit Ein- und Ausgaben experimentieren, werden Sie rasch feststellen, dass oft       Stellen Sie sich vor, Sie haben einen eine Folge von Anweisungen, die mehrmals im
ein Problem auftritt: Sie haben zwei mal hintereinander die Funktion readkey stehen, aber    Programm vorkommt, z.B. eine komplizierte mathematische Berechnung. Anstatt dieses
das Zweite der beiden wird einfach übersprungen. Dies kommt daher, das Sie einfach zu        Codestück mehrmals zu schreiben (was Zeit beim Erstellen und Warten des Programms
langsam sind. Ohne Scherz: Wenn Sie eine Taste drücken, bleiben Sie mit dem Finger           kostet und außerdem den Sourcecode und die ausführbare Datei vergrößert), können Sie
                                                                                                                                                                                  8
ein sogenanntes "Unterprogramm" schreiben. Dieses Unterprogramm können Sie dann             •   Vor dem letzten end der Funktion muss noch der Funktionswert zugewiesen
von jeder Stelle ihre Hauptprogramms aus aufrufen, so wie die bereits bekannten                 werden. Das ist jener Wert, der im Hauptprogramm der Variablen zugewiesen
Unterprogramme read, write, readkey, etc.                                                       wird (Sehen Sie sich das Beispiel an, dass sollte Klarheit schaffen). Dazu geben
                                                                                                Sie lediglich folgendes an: "Funktionsname := Wert". Natürlich müssender
Funktionen (function)                                                                           Rückgabewert der Funktion und der zugewiesen Wert den selben Datentyp
Syntax: function Name(Parameterliste):Rückgabe-Typ;                                             haben.
Funktionen sind Unterprogramme, die am Ende ihrer Ausführung einen Wert                     •   Im Anweisungsteil wird die Funktion einfach mit ihrem Namen und eventuell
zurückliefern, wie z.B. readkey. Paradebeispiele für die Anwendung eine Function sind           den Parametern aufgerufen.
jedoch mathematische Formeln:                                                               •   Die textuelle Einrückung der Funktion nach rechts ist nicht notwendig, es dient
                                                                                                lediglich der Übersichtlichkeit.
pa_5_1.pas
                                                                                        Prozeduren (procedure)
PROGRAM Functions_Test;                                                                 Syntax: procedure Name(Parameterliste);
USES crt;                                                                               Eine Procedur ist nichts anderes als eine Funktion ohne Rückgabewert. Sie ähnelt daher
VAR Zahl1:integer;                                                                      prinzipiell einer Funktion, bis auf folgende Unterschiede:
                                                                                            • Es darf kein rückgabe-Datentyp in der Definition angegeben werden, da kein
  FUNCTION hoch2(Param1:integer):integer;                                                        Wert zurückgeliefert wird.
  BEGIN                                                                                     • Eine Procedure kann daher beim Aufruf auch nicht einer Variablen zugewiesen
    hoch2 := Param1*Param1;
                                                                                                 werden sonder wird wie eine normale Anweisung behandelt (wie z.B. writeln).
  END;

BEGIN
  write('Zahl: ');                                                                      pa_5_2.pas
  readln(Zahl1);
  Zahl1:=hoch2(Zahl1);                                                                  PROGRAM procedure_test;
  writeln('Eingabe hoch 2 = ',Zahl1);                                                   USES crt;
  writeln('5 hoch 2 = ', hoch2(5));                                                     VAR Zahl1:integer;
  readkey;
END.                                                                                        PROCEDURE ausgeben(Param1:integer);
                                                                                            BEGIN
Bemerkungen zum Programm:                                                                     writeln('Der Wert der Variablen beträgt: ',Param1);
   • Ein Unterprogramm steht immer im Deklarationsteil eines Programms (oder                END;
       eines anderen Unterprogramms).
   • Nach dem reservierten Wort function folgt der Name der Funktion, dann falls        BEGIN
       notwendig die Parameter inklusive Datentyp (werden mehrere Parameter                ausgeben(23);
       unterschiedlicher Datentypen benötigt, dann muss man zwischen diesen einen          Zahl1:=4;
       Strichpunkt setzen). Anschließend folgt ein Doppelpunkt und der Rückgabe-           ausgeben(Zahl1);
       Datentyp der Funktion (dieser muss ein Standard-Datentyp sein). Zum Schluss      END.
       folgt noch der obligatorischen Strichpunkt.
   • Im Anweisungsteil der Funktion können ganz normal alle Anweisungen                 Bemerkungen zum Programm:
       ausgeführt werden. Außerdem kann eine Funktion vor dem Anweisungsteil einen         • Durch den Befehl "ausgeben(23);" wird die Prozedur "ausgeben" mit dem
       eigenen Deklarationsteil ("var ...") besitzen.                                          Parameter "23" aufgerufen. Param1 hat also den Wert 23. Die einzige Anweisung
                                                                                               innerhalb der Prozedur ist writeln, die nun ausgeführt wird.
                                                                                                                                                                              9
    •   Danach wird mit dem nächsten Befehl innerhalb des Hauptprogramms fortgesetzt         Array
        ("Zahl1:=4").                                                                        In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und
    •   Der zweite Aufruf von ausgeben erfolgt mit dem Parameter Zahl1, also wird            hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen, mit
        Param1 der Wert 4 zugewiesen. Dieser wird nun wieder mittels writeln ausgeben.       nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit z.B.
                                                                                             einer for-Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, sie müssten
Die Funktionen ord und chr                                                                   mit 100 verschiedenen Variablen Zahl_001 bis Zahl_100 arbeiten! Ein ihnen bereits
Diese beiden Funktionen kommen meist im Zusammenhang mit char-Variablen vor. char-           bekanntes Beispiel für ein Array ist der Datentyp string. Dabei handelt es sich nämlich um
Variablen speichern bekanntlich Zeichen, zumindest scheint es so. In Wirklichkeit wird       ein Array des Datentyps char (mit einigen wenigen Veränderungen).
nur die Nummer des Zeichens gespeichert, so hat "A" z.B. die Nummer (den "ASCII-
Code") 65, B die Nummer 66, usw. Um die Nummer, den sogenannten Ordinalwert eines            Syntax: var Name: array [von..bis] of Datentyp;
Zeichens oder einer char-Variable zu erhalten, benutzt man die Funktion ord. Das Ganze       Der Name muss ein gültiger Bezeichner sein, als Datentyp kann jeder beliebige Typ
funktioniert auch in die Gegenrichtung mit der Anweisung chr, die das Zeichen                genommen werden. In der eckigen Klammer wird die Anzahl der Elemente
zurückliefert, das den Wert des Parameters trägt.                                            bekanntgegeben. "von" bezeichnet die Nummer (den Index) des ersten, "bis" die Nummer
                                                                                             des letzten Elementes. Ein mit [1..3] definiertes Array hat also drei Variablen, nämlich [1],
pa_5_3.pas                                                                                   [2] und [3]. Um auf eine der im Array enthaltenen Variable zugreifen zu können, müssen
                                                                                             Sie den Variablen-Namen und in eckigen Klammern den Index ("Nummer") der Variablen
PROGRAM ord_chr;                                                                             angeben. Diese Variable verhält sich dann wie eine ganz normale Variable des jeweiligen
VAR Zahl1:integer;                                                                           Datentyps.
     Zeichen1:char;
BEGIN                                                                                        pa_6_1.pas
  Zahl1:=ord('A');
  Zahl1:=Zahl1+1;                                                                            PROGRAM array_test;
  Zeichen1:=chr(Zahl1);                                                                      USES crt;
END.                                                                                         VAR Zahlen: ARRAY [1..10] OF integer;
                                                                                                  i: integer;
Erklärung:                                                                                   BEGIN
    • Zahl1 wird der Ordinalwert von 'A' (also 65) zugewiesen.                                 clrscr;
    • Zahl1 wird um 1 erhöht, hat also den Wert 66.                                            FOR i:= 1 to 10 DO
    • Der Variablen Zeichen1 wird das Zeichen mit der Nummer 66, also 'B'                      BEGIN
        zugewiesen.                                                                               write('Bitte Zahl ',i,' eingeben: ');
                                                                                                  readln(Zahlen[i]);
                               Felder, Typen, Strukturen                                       END;
                                                                                               writeln('Danke!');
Felder                                                                                         FOR i:= 1 to 10 DO write('Zahl ',i,' war: ',Zahlen[i]);
                                                                                             END.
Oft muss man sehr viele Werte gleichzeitig abspeichern und betrachten, die alle der selben
Aufgabe dienen. Man schreibt z.B. ein Programm, das 10 Zahlen einlesen und
anschließend wieder ausgeben soll. Mit dem bisherigen Wissen würden Sie vermutlich 10        Bemerkungen:
verschiedene Variablen anlegen (zahl1 zahl2, ...), aber es geht auch einfacher. "Felder"        • Zuerst wird ein Array mit angelegt, das zehn integer-Werte speichert.
oder "Arrays" speichern mehrere Werte gleichen Datentyps. Jedes Array hat einen                 • In dieses speichert das Programm nun der Reihe nach zehn Zahlen, die der
normalen Variablen-Namen, die einzelnen Variablen können mit einem "Index"                          Benutzer eingeben kann.
angesprochen werden.                                                                            • Anschließend werden alle zehn Zahlen noch einmal ausgegeben.


                                                                                                                                                                                      10
ACHTUNG!: Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration             Eigene Datentypen
"von..bis" nicht enthalten ist) können je nach Compiler und Einstellung mehrere Dinge        Mit Hilfe des Schlüsselwortes type können Sie im Deklarationsteil eigene Typen
geschehen: entweder liefert der Compiler einen "Bereichsüberschreitungs-" Fehler, oder       definieren. Dabei gibt es mehrere Möglichkeiten.
das Programm funktioniert nicht oder einfach komplett falsch (im schlimmsten Fall könnte
sogar der Computer abstürzen). Also achten Sie darauf, dass Sie keine ungültigen Werte       eigene Datentypen
als Index angeben!                                                                           Das stimmt eigentlich nicht ganz; man kann lediglich andere Namen für bereits
                                                                                             bestehende Datentypen vergeben. Das ist jedoch sinnvoll, wenn Sie z.B. einen Datentyp
Mehrdimensionale Arrays                                                                      für ein Array anlegen. Das kann eine Menge Schreib-Arbeit ersparen!
Manchmal benötigen mehr als nur ein ein-dimensionales Array, wie sie es bisher kennen.
Auch dies ist in Pascal kein Problem. In der Deklaration geben Sie in den eckigen            PROGRAM Type_test;
Klammern einfach mehrere von..bis an, mit Beistrich voneinander getrennt. Aber               TYPE feld=array[1..20,1..30] of integer;
Vorsicht: der Speicherplatz ist begrenzt, ein array [1..1024,1..1024] of char hat die        VAR a,b,c:feld;
Speicherplatzgrenzen bereits weit überschritten, und der Compiler wird einen (bei            ....
gewissen Einstellung auch keinen) Fehler liefern (dieses Problem haben Sie [natürlich] nur
unter DOS). Beim Schreiben oder Lesen von Werten in das/aus dem Array müssen Sie bei         Bemerkungen:
mehrdimensionalen Feldern auch mehr als einen Index angeben, die Erklärung folgt als         Was in diesem Beispiel noch nicht so deutlich wird, kann bei einem größeren Projekt viel
Beispiel:                                                                                    Arbeit sparen: Wenn Sie viele Unterprogramme haben, brauchen Sie bei der
                                                                                             Parameterübergabe nicht jedes mal das lange ARRAY[....] OF Datentyp schreiben.
pa_6_2.pas                                                                                   Außerdem wird das Programm verständlicher, wenn Sie für den Datentypen einen
                                                                                             halbwegs aussagekräftigen Namen wählen.
PROGRAM mehr_dimensionales_Array;
                                                                                             Strukturen (record)
VAR feld: ARRAY[1..3,1..5] of integer;                                                       Mit Hilfe von record können Sie "Strukturen" definieren. Dabei handelt es sich um eine
    x,y: integer;                                                                            Zusammenfassung von mehreren Datentypen zu einem Größeren. Im Gegensatz zu Arrays
                                                                                             können in Records jedoch unterschiedliche Datentypen gespeichert werden:
BEGIN
  for x:= 1 to 3 do for y:= 1 to 5 do                                                        PROGRAM records_test;
  BEGIN                                                                                      TYPE Person=RECORD
    write('Feldwert X: ',x,' Y: ',y);                                                          Vorname,Nachname:string;
    readln(feld[x,y]);                                                                         strasse,ort:string;
  END                                                                                          hausnummer:integer;
  for x:= 1 to 3 do for y:= 1 to 5 do write('Wert: ',x,'                                       plz:longint;
',y,' ',feld[x,y]);                                                                          end;

END.                                                                                         VAR MeinChef:Person;
                                                                                             ....
Erklärung:
    • Zuerst wird ein 3 mal 5 integer-Array angelegt.                                        Wie spricht man die einzelnen Variablen eines Records nun an? Das funktioniert so:
    • Dann werden die Werte eingegeben: zuerst feld[1,1], dann feld[1,2], usw. bis               • Zuerst gibt man die Record-Variable an, im Beispiel MeinChef.
        feld[3,5].                                                                               • Danach schreibt man einen Punkt.
    • Zum Schluß werden alle Werte noch einmal ausgegeben.                                       • Abschließend folgt die gewünschte Variable, also z.B. Vorname.
                                                                                                 • Also: Recordtyp.Variable, im Beispiel: MeinChef.Vorname

                                                                                                                                                                                  11
Die Anwendung verdeutlicht folgendes Beispiel (Typen und Variablendeklaration des           Nach der Ausführung von assign können Sie die Datei öffnen. Dazu müssen Sie einen der
letzten Beispieles):                                                                        beiden Befehle reset oder rewrite ausführen. Beide verlangen als Parameter ein
                                                                                            Dateihandle. reset öffnet die Datei; gibt es die Datei nicht, erhalten Sie eine
....                                                                                        Fehlermeldung. Bei einer noch nicht existierenden Datei müssen Sie rewrite verwenden.
MeinChef.Vorname:='Max';                                                                    Dieser Befehl öffnet ebenfalls die Datei. Wenn sie schon besteht wird sie gnadenlos
MeinChef.Nachname:='Mustermann';                                                            überschrieben; existiert sie noch nicht, wird sie neu angelegt.
Readln(MeinChef.strasse);
....
                                                                                            Schließen einer Datei
                                        Dateien                                             Wenn Sie alle Schreib- und Leseoperationen beendet haben, sollten Sie die Datei
                                                                                            schließen. Dies ist wichtig, um sicherzustellen, das sich Daten nicht noch in einem
Dateiverarbeitung                                                                           System-Puffer befinden, sondern dass wirklich alle Daten in die Datei geschrieben
Variablen im Arbeitsspeicher sind äußerst flexibel, sie haben nur einen großen Nachreil:    wurden.
sie "überleben" eine Programmbeendigung nicht. Wäre doch praktisch, wenn man Sie wo
speichern könnte! Vielleicht in einer Datei auf der Festplatte ...                          Die Anwendung ist einfach: "close(Dateihandle);". Das Beispiel dazu finden Sie etwas
Unter Pascal Dateien anzusprechen ist sehr einfach. Mit einigen wenigen Befehlen können     weiter unten ("Lesen einer Datei").
Sie schon Binär- und Textdateien verarbeiten, von ihnen lesen und in sie schreiben.

Öffnen einer Datei                                                                          Schreiben in eine Datei
Zuerst müssen Sie dem System die zu öffnende Datei bekannt geben. Das geschieht mit         ACHTUNG: Passen Sie auf, in welche Datei Sie schreiben! Pascal überschreibt (falls Sie
dem Befehl assign. Diese Anweisung erwartet zwei Parameter: ein sogenanntes "Datei-         es "befehlen") gnadenlos "autoexec.bat", "command.com", ihre Lieblingsgrafik oder die
Handle" und einen Dateinamen inkl. Pfadangabe. Das Dateihandle ist eine Variable von        exe-Datei der Textverarbeitung. Unbedingt aufpassen! Egal, ob Sie jetzt mit einer binären
Typ text (für Textdateien) oder von Typ "file of Typ", wobei "Typ" ein beliebiger           oder mit einer textuellen Datei arbeiten, können Sie mit dem write(ln) Werte in die Datei
Datentyp sein kann.                                                                         schreiben. Erinnern Sie sich noch an den Abschnitt über Drucker? Dort mussten Sie bei
                                                                                            einer Ausgabe auf den Drucker als ersten Parameter "lst" angeben. Klingelts? Könnte das
.....                                                                                       vielleicht so eine Art Handle gewesen sein? Ja, es ist so.
VAR textDatei:text;
    intDatei:file of integer;                                                               Wollen Sie also in eine Datei schreiben, geben Sie als ersten Parameter das Dateihandle
begin                                                                                       an. Als weitere Parameter geben Sie dem Datentyp des Dateihandels entsprechende Werte
  assign(textDatei,'readme.txt');                                                           bzw. Variablen an, die Sie in die Datei schreiben möchten. Dabei müssen Sie auf eines
  assign(intDatei,'A:\datei.dat');                                                          achten: Wenn Sie in eine Datei lauter integer-Zahlen speichern, diese Datei schließen, als
.....                                                                                       char-Datei wieder öffnen und auslesen, bekommen Sie lauter Sch.....öne, aber
                                                                                            nichtssagende ASCII-Zeichen. Eine binäre integer-Datei sollte also immer nur als solche
Die Anweisung assign verbindet einen Dateinamen mit einem Handle. Dabei wird                gelesen und geschrieben werden, und nicht als char oder gar text-Datei geöffnet werden.
allerdings NICHT überprüft, ob die Datei existiert!
                                                                                            Bei einer Textdatei sind Sie nicht an Datentypen gebunden. Wenn Sie in eine Textdatei die
Bemerkung: Ein Datei-Handle ist ein System-interner Name für eine Datei. Viele              Zahl "12345" speichern, wird diese nicht als 2-Byte-Integer dort gespeichert, sondern als
Betriebssystem speichern Informationen über die geöffneten Dateien in einem Array ab        die ASCII-Zeichen "1", "2", "3", "4" und "5". Danach können Sie einen String, eine Byte-
(Name der Datei, welches Programm darauf zugreift, ...). Um eine Datei öffnen zu            Zahl, etc. speichern. Sie müssen nur aufpassen, dass die Werte (Datentypen) in der selben
können, muß man zuerst ein freies Array-Element "zugeteilt" bekommen, in dem die Infos      Reihenfolge wieder ausgelesen werden, sonst wird der String als Zahl und die Zahl als
über die Datei stehen werden. Dies geschieht mit dem Befehl assign. Das zurückgelieferte    Wahrheitswert interpretiert :-).
Datei-Handle ist in vielen Fällen der Index der Datei innerhalb des Arrays. Dieses System
erleichtert sowohl dem Programmierer des Betriebssystems als auch Ihnen die Arbeit!
                                                                                                                                                                                   12
pa_7_1.pas
                                                                                             Die vorher gespeicherten Zahlen werden wieder gelesen und ausgegeben.
program schreibeIntegerDatei;
uses crt;                                                                                    Falls Sie Interesse daran haben, können Sie die "file of integer" in beiden Programmen
var i:integer;                                                                               gegen "text" austauschen, und die erzeugten Dateien der beiden Versionen vergleichen.
    datei:file of integer;                                                                   Bei der text-Variante sollte das Ergebnis lesbar sein, für die file of integer-Version
begin                                                                                        brauchen Sie schon einen Hex-Editor, um sinnvolle Werte darin zu erkennen.
  assign(datei,'text.dat');
  rewrite(datei);                                                                            Ich möchte nochmals darauf hinweisen, dass es nicht sehr sinnvoll ist, aus einer Datei
                                                                                             binär Daten zu lesen, wenn diese mittels "text" hineingeschrieben wurden. Es ist zwar
  for i:= 1 to 10 do                                                                         durchaus möglich, aber die Werte die Sie herauslesen sind dann nicht die selben die Sie
  begin                                                                                      hineingeschrieben haben.
     write(datei,i);
  end;                                                                                       Das Ende?
  close(datei);                                                                              Sie sind jetzt am Ende dieses Tutorials angekommen. Doch der Spaß hat erst begonnen. Es
end.                                                                                         gibt so viele Möglichkeiten, von denen Sie in diesem Tutorial noch nichts gehört haben:
                                                                                             Grafik, Units selber schreiben, Hardware-Programmierung, uvm. Doch mit dem hier
Es werden alle Zahlen von 1 bis 10 binär in die Datei geschrieben. Ersetzten Sie in dem      vermittelten Wissen ist es nicht mehr weit, bis Sie umfangreiche Programme schreiben
Beispiel ruhig einmal das "file of integer" durch "text", und schreiben Sie in eine andere   können. Was Sie dazu brauchen, ist vermutlich die Pascal-Hilfedatei ihres Compilers, und
Datei (zB. "text2.txt"). Dann vergleichen Sie mit einem Text- oder Hexeditor die beiden      etwas Mut, neue Dinge auszuprobieren.
Dateien.

Lesen aus der Datei
Mit der bekannten read(ln) Anweisung können Sie Daten aus einer Datei lesen. Am besten
sieht man das im folgenden Beispiel:

pa_7_2.pas
program leseIntegerDatei;
uses crt;
var i,zahl:integer;
     datei:file of integer;
begin
   assign(datei,'text.dat');
   reset(datei);

  clrscr;
  for i:= 1 to 10 do
  begin
     read(datei,zahl);
     write('Der ',i,'. Wert ist: ',zahl);
  end;
  close(datei);
end.

                                                                                                                                                                                  13

				
DOCUMENT INFO
Shared By:
Stats:
views:15
posted:3/26/2010
language:German
pages:13