Component Pascal Ein Tutorium - Programmieren mit
←
→
Transkription von Seiteninhalten
Wenn Ihr Browser die Seite nicht korrekt rendert, bitte, lesen Sie den Inhalt der Seite unten
Harro von Lavergne
Strukturiertes, modulares, objekt- und komponenten-
orientiertes
Programmieren
mit
Component
Pascal
Ein TutoriumCOMPONENT PASCAL - EIN TUTORIUM INHALT
INHALT
KAPITEL 1
COMPUTERPROGRAMME . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Was ist ein Programm? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.1. Component Pascal Programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2. Kommandoprozeduren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3. Der Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
KAPITEL 2
GRUNDLAGEN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1. Ausgabeanweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2. Kommentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.3. Die Form eines Programms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
KAPITEL 3
EINFACHE DATENTYPEN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.1. Konstanten und Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2. Ganzzahlmathematik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.3. Die reellen Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.4. Logische Entscheidungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.5. Zeichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
KAPITEL 4
KONTROLLSTRUKTUREN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.1. Wiederholungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Die REPEAT - Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Die WHILE - Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Die FOR - Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Die LOOP - Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.2. Bedingte Verzweigungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.3. Schleifen - Zweige - Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.4. Mehrfachverzweigungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4.5. Eingabe von Daten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Harro von Lavergne COMPONENT PASCAL - Ein TutoriumCOMPONENT PASCAL - EIN TUTORIUM INHALT
KAPITEL 5 KAPITEL 9
PROZEDUREN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 DIALOGE - Entwurfsmuster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
5.1. Parameterlose Prozeduren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 9.1. Interaktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
5.2. Prozeduren mit einem Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 9.2. Notifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
5.3. Prozeduren mit mehreren Parametern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 9.3. Textfenster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
5.4. Sichtbarkeitsbereiche von Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 9.4. Guards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
5.5. Stil ist eine Geschmacksfrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 9.5. Das Model - View - Controller Muster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
5.6. Sichtbarkeitsbereiche von Prozeduren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
5.7. Rekursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 KAPITEL 10
5.8. Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 ZEIGER - Der Datentyp POINTER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
10.1. Zeiger sind Datenadressen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
KAPITEL 6 10.2. Daten und Zeiger - Speichernutzung dynamisch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
MENGEN- UND PROZEDURTYPEN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 10.3. Statische und dynamische Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
6.1. Mengentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 10.4. Stapel - Das FILO-Prinzip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
6.2. Prozedurtypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 10.5. Schlangen - Das FIFO-Prinzip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
KAPITEL 7 KAPITEL 11
FELDER - Der Datentyp ARRAY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 LINEARE LISTEN - Datenabstraktion
7.1. Eindimensionale Felder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
7.2. Mehrdimensionale Felder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 KAPITEL 12
7.3. Typbindung bei Feldern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 BINÄRE BÄUME - Komponenten
7.4. Offene Feldparameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
7.5. Zeichenketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 ANHANG
Latin 1 - Zeichentabelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A 1
KAPITEL 8 Component Pascal Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . B 1
VERBUNDE - Der Datentyp RECORD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 Schlüsselbezeichner und Standardprozeduren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C 1
8.1. Nicht erweiterbare Verbunde . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 Sonderzeichen und Schlüsselwörter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C 1
8.2. Daten und Verbunde . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 Standard - Bezeichner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C 2
8.3. Vererbung - Klassen - Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 Standard - Prozeduren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C 3
Erweiterbare Verbunde . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 UML-Diagramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . D 1
Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
Typgebundene Prozeduren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
Harro von Lavergne COMPONENT PASCAL - Ein TutoriumKAPITEL 1 - COMPUTERPROGRAMME 5
KAPITEL 1
COMPUTERPROGRAMME
Was ist ein Programm?
Die Frage, was ein Computerprogramm sei, ist nur schwer umfassend zu beantworten - aber es gibt
eine einfache Näherung: Ein Programm ist eine Sammlung von Anweisungen an den Computer. Der ist
nun - mit menschlichen Maßstäben gemessen - überaus dumm, d.h. er tut nichts von alleine (das ist wahr-
scheinlich ganz gut so), aber wenn er etwas tut, so tut er genau das, was den gegebenen Anweisungen ent-
spricht. Diese Feststellung wird Sie, wie jede(n) von uns, noch manches Mal zur Verzweiflung bringen,
wenn nämlich die Maschine wieder einmal nicht tut, was sie tun soll, sondern irgend etwas Unerwartetes.
Dabei hat sie genau das getan, was den gegebenen Anweisungen entsprach, nur waren die offensichtlich
nicht so gemeint. Ein Computer "weiß" aber leider nie, was gemeint war, im Gegensatz zu den netten Men-
schen in unserem Leben, die immer so tun, als ob sie es wüßten, der Computer nimmt alles äußerst wört-
lich. Es kommt beim Schreiben von Programmen also auf Präzision und logische Klarheit an, in dieser
Hinsicht ähnelt die Programmierung eines Computers der Mathematik. Als beruhigenden Ausgleich dafür
kann man vielleicht die Tatsache ansehen, daß die Maschine niemals ungeduldig wird. Sie dürfen, ohne rot
zu werden, all die Fehler auch machen, die jede(r) von uns gemacht hat und wieder machen wird.
Unter dem Gesichtspunkt der Verarbeitung durch den Computer ist ein Programm am einfachsten als
Rezept zu verstehen. Man gibt zuerst die Zutaten an und erklärt dann, was jeweils in welcher Reihenfolge
und Kombination mit den bereitgestellten Zutaten erfolgen soll. Nun gibt es Rezepte, die aus guten Zutaten
schlechtes Essen machen, dann sind mit ziemlicher Sicherheit die Anweisungen für die Verarbeitung
schlecht gewesen; im schlimmsten Fall kommt etwas Ungenießbares oder gar Gesundheitsschädliches
heraus. Umgekehrt kann auch ein Meisterkoch aus falschen oder zu wenigen Zutaten kein großartiges
Essen machen; fehlen die richtigen Gewürze, wird das fertige Gericht fade und nicht sehr schmackhaft.
Für die Programmierarbeit heißt das: es kommt sowohl darauf an, die richtigen Zutaten in ausreichen-
der Menge und Vielfalt zu verwenden, als auch darauf, sie geeignet miteinander zu verbinden, um das Ge-
wünschte zu erzeugen. Und ebenso wie man sich beim Kochen stets auf die gleichen drei Zutaten und die
gleiche Verarbeitungsmethode beschränken kann, wodurch man - mit kleinen Variationen - im Wesentli-
chen auch stets das gleiche Gericht auf dem Teller hat, kann man sich beim Programmeschreiben auf
einige wenige Standardverfahren beschränken; man kommt erstaunlich weit damit, aber es ist irgendwo
dürftig und fade: eben Imbissbude.
COMPONENT PASCAL - Ein Tutorium COMPONENT PASCAL - Ein Tutorium6 KAPITEL 1 - COMPUTERPROGRAMME 1.1. Component Pascal Programme 7
Versuchen Sie möglichst bald, sich die verschiedenen Konstruktionen und Methoden, die Component mern - können Sie weglassen, es handelt sich um Kommentartext, der nur für Sie, den Leser, nicht für den
Pascal in gut überlegter Konzeption zur Verfügung stellt, anzueignen und sich die Unterschiede zwischen Compiler gedacht ist. (Mehr dazu im Zusammenhang mit Programm 2 des nächsten Kapitels: Kom-
ähnlichen, aber nicht identischen Verfahren klarzumachen, so daß Sie diese später gezielt bei Ihren eigenen ment.odc).
Programmen einsetzen können. Je besser Sie die grundlegenden Einzelheiten verstanden haben, desto Sie finden im Programm A.odc diejenigen Zutaten, die mindestens zu jedem Component Pascal Pro-
leichter wird es Ihnen fallen, eigene Rezepte zu erfinden und sie so zu verändern, daß das Ergebnis wirk- gramm gehören. Der Grundbaustein eines Component Pascal Programms ist das Modul. Dieses beginnt mit
lich Ihren Vorstellungen entspricht. Auch in dieser Hinsicht ist es bei Computerprogrammen wie beim dem sogenannten Modulkopf und endet mit einem Punkt. Der Modulkopf besteht aus dem Schlüsselwort
Kochen, die Variationen oder auch Neuschöpfungen gelingen umso leichter und selbstverständlicher, je MODULE und dem Modulnamen. Schlüsselwörter nennt man auch Reservierte Bezeichner, dies sind Zei-
besser man das jeweilige "kleine EinMalEins" beherrscht. chen oder Wörter mit einer festgelegten und unveränderbaren Bedeutung 1. Dem Schlüsselwort MODULE
Man kann den Weg von der Idee bis zum gelungenen Produkt, die strukturierte Zerlegung des Ge- folgt (mindestens) ein Leerzeichen, dann der Modulname und schließlich ein Semikolon. Component
samtgedankens in Einzelteile und geeignete Verarbeitungsmethoden und schließlich das erneute Zusam- Pascal benötigt im Anschluss an das Wort MODULE stets einen Namen (hier TutA), der wenigstens aus
menfügen der Teile als schöpferische Kreativität bezeichnen; in der Sprache der Informatiker klingt das ein einem Buchstaben bestehen muß. Anstelle von TutA könnten z.B. auch die Wörter Opossum oder Mond-
klein wenig erschreckender, in ihr heißt der Vorgang "Algorithmisierung". Sie sollten sich aber von der kalb stehen, irgendeine Zeichenfolge also, die als Modulname dient. Sie dürfen sich diese Zeichenfolge
Befremdlichkeit des Wortes nicht verunsichern lassen, gemeint bleibt die Umsetzung eines guten Gedan- weitgehend frei aussuchen, Sie sollten dabei möglichst nur Buchstaben (und eventuell Ziffern) verwenden,
kens in ein gutes, reproduzierbares Ergebnis und dabei kann Ihnen die Beherrschung der in Component auch wenn einige andere Zeichen erlaubt sind, die Sie auf der Tastatur finden. In jedem Fall aber muß das
Pascal steckenden Möglichkeiten helfen. erste Zeichen des Namens ein Buchstabe sein.
Dem Modulnamen muß stets ein Semikolon folgen und innerhalb des Namens sind in keinem Fall
Leerzeichen erlaubt. Leerzeichen haben in Component Pascal eine besondere Funktion, sie trennen Schlüs-
1.1. Component Pascal Programme selwörter (z. B. das Wort MODULE) und andere Bezeichner (hier der Modulname TutA) voneinander.
Über diese unbedingt notwendigen Leerzeichen hinaus können Sie an (fast) beliebiger Stelle eines Moduls
Laden Sie die Datei A.odc in die BlackBox Systemumgebung und lassen Sie das Modul kompilieren, weitere Leerzeichen in (fast) beliebiger Menge einfügen; dies ist eine sehr nützliche Eigenschaft, da sie
d.h. in die Sprache des Computers übersetzen. Klicken Sie dazu im Menü Dev auf das Kommando Com- Ihnen und mir erlaubt, Programme so zu schreiben, daß sie lesbar und übersichtlich sind.
pile. Sie erhalten im Log-Fenster eine Meldung compiling ... Das bedeutet, die Kompilation ist korrekt er- Weiter finden Sie im Modul TutA das Schlüsselwort END. Dem END folgen die Wiederholung des
folgt, es hat keine Fehler(meldung) gegeben. Sie werden merken, daß dies eigentlich die Ausnahme dar- Modulnamens (hier also TutA) und ein Punkt, der unbedingt benötigt wird; er signalisiert dem Compiler,
stellt. Nicht nur am Anfang Ihrer Programmierarbeit, sondern auch nach jahrelanger Erfahrung werden Sie daß an dieser Stelle das gesamte Modul zu Ende ist. Das Wort END allein reicht deshalb nicht, weil es als
immer wieder Fehlermeldungen erhalten, wenn Sie einen eigenen oder auch fremden Programmentwurf END anderer innerhalb des Moduls stehender Programmblöcke mehrfach vorkommen kann, also nicht in
kompilieren lassen. Sie brauchen also keineswegs zu verzweifeln, wenn Ihre Arbeit nicht sofort zum be- jedem Fall das definitive Modulende bedeutet.
absichtigten Ergebnis führt, Programmierprobleme gehören für Anfänger wie für die Erfahrensten zur täg- Sie werden jetzt möglicherweise fragen, welchen Sinn das Modul TutA hat, da es nichts enthält. Mo-
lichen Arbeit und oft bestehen die Schwierigkeiten nicht so sehr in der Erstellung eines Programms, son- dule sind in Component Pascal die Einheiten der Kompilation. Man kann sie als Behälter ansehen, die not-
dern im Auffinden und Beseitigen von Fehlern. wendig sind, um die in ihnen (potentiell) vorhandenen Einzelteile zusammenzuhalten. Diese Einzelteile
Zurück zum Programm A.odc. Es gab bei der Kompilation keine Fehlermeldung, d.h. das Programm können nicht selbständig existieren, sie brauchen eine "Umhüllung", das umgebende Modul. Das Modul
ist aus der Sicht des Compilers korrekt. Er kann es übersetzen, ohne daß etwas fehlt oder unverständlich ist in Component Pascal der Grundbaustein, die (einzige) kompilationsfähige Einheit.
ist. Versuchen Sie, irgendein Zeichen zwischen dem M des Wortes MODULE und dem Punkt am Ende der
Zeile END TutA. wegzunehmen, lassen Sie das Programm erneut kompilieren und Sie werden sehen, daß
Sie eine Fehlermeldung auf den Bildschirm bekommen. Anders gesagt: Sie haben das minimale Compo-
nent Pascal Programm vor sich. Lediglich die beiden Zeilen der Überschrift - den Text in den (* *)-Klam- 1
Eine Liste mit Reservierten Bezeichnern finden Sie im Anhang C.
Harro von Lavergne COMPONENT PASCAL - Ein Tutorium8 KAPITEL 1 - COMPUTERPROGRAMME 1.2. Kommandoprozeduren 9
1.2. Kommandoprozeduren lassen Sie es wie beschrieben ausführen, so erscheint als Ergebnis im Log-Fenster der Text des Gedichtes
von Christian Morgenstern.
Mit dem nächsten Programm, Morgenstern.odc, haben Sie ein Component Pascal Modul vor sich, das Sie sollten sich im Augenblick keine Gedanken um den übrigen Inhalt des Moduls machen, die Ein-
nicht nur kompilierbar ist wie das Modul TutA, sondern darüber hinaus eine - wenn auch einfache - Aktion zelheiten werden im 2. Kapitel im Zusammenhang mit dem Programm Text.odc erklärt, wichtig ist im
ermöglicht. Aktionen können in Component Pascal entweder durch den Benutzer oder durch andere Pro- Augenblick lediglich, daß Sie das Modul erfolgreich kompiliert und das Kommando TutMorgenstern.Start
gramme bewirkt werden. Das zweite dieser Verfahren werden Sie später kennen lernen, das Modul Tut- mit dem gewünschten Ergebnis aktiviert haben.
Morgenstern macht Sie mit der Möglichkeit bekannt, als Benutzer eine Aktion auszulösen.
Grundsätzlich ist Component Pascal eine ereignisgesteuerte Programmiersprache, in der alle Aktionen
von Prozeduren ausgeführt werden. Sie sehen in dem Modul TutMorgenstern eine solche Prozedur mit 1.3. Der Compiler
dem Namen Start. Eine Prozedur ist fast genauso aufgebaut wie ein Modul, sie besteht aus einem Proze-
durkopf, der sich zusammensetzt aus dem Schlüsselwort PROCEDURE und dem Prozedurnamen. Das Laden Sie das Programm Hallo.odc und kompilieren Sie das Modul. Im Log-Fenster erhalten Sie die
Ende der Prozedur wird wie bei einem Modul durch das Schlüsselwort END gefolgt vom Prozedurnamen Meldung compiling 2 errors detected und im Quelltext erscheinen zwei Fehlermarken an den Positionen
gebildet, wobei diesem Namen kein Punkt, sondern ein Semikolon folgt. Zwischen diesen beiden Pro- der Fehler. Doppel-Klicken Sie auf die erste dieser Fehlermarken, entfaltet sie sich zu dem Text undecla-
grammzeilen steht der Rumpf genannte Teil der Prozedur, der die eigentlichen Handlungsanweisungen ent- red identifier. Ändern Sie den dem Compiler nicht bekannten Bezeichner OutString, indem Sie einen sepa-
hält (genaueres zu Prozeduren erfahren Sie im 5. Kapitel). rierenden Punkt einfügen (Out.String; genaueres zu diesem Bezeichner erfahren Sie im nächsten Kapitel
Im vorigen Abschnitt wurde erläutert, daß ein Modul eine Kompilationseinheit ist, eine Umhüllung. im Zusammenhang mit dem Programm Text.odc). Doppel-Klicken Sie auf die zweite Fehlermarke, es er-
Damit es eine Interaktion zwischen dem Modul(inneren) und der Außenwelt geben kann, muß das Modul scheint der Text identifier expected. Fügen Sie ein Leerzeichen und den fehlenden Modulnamen (TutHallo)
eine sogenannte Schnittstelle (Englisch: interface) haben, über die die außerhalb zur Verfügung stehenden vor dem Punkt ein. Lassen Sie das Programm neu kompilieren. Im Log-Fenster erscheint die Meldung
Dienste exportiert werden. Zu exportierende Bezeichner werden in Component Pascal durch ein nachge- compiling 28 0, das Modul wurde übersetzt, es ist syntaktisch fehlerfrei und es sind zwei Dateien erzeugt
stelltes Sternchen (*) kenntlich gemacht. Das Modul TutMorgenstern exportiert somit einen einzigen Be- worden, Hallo.ocf mit dem lauffähigen Programmcode im Unterverzeichnis Tut/Code des Arbeitsver-
zeichner, die Prozedur Start. zeichnisses sowie die Symboldatei Hallo.osf mit der Beschreibung der vom Modul TutHallo exportierten
Exportierte Prozeduren wie Start, die im Prozedurkopf nur den Namen enthalten, werden in Compo- Bezeichner im Unterverzeichnis Tut/Sym.
nent Pascal auch als Kommandoprozeduren oder kurz Kommandos bezeichnet, da sie außerhalb des Mo- Markieren Sie jetzt das unterhalb des Moduls stehende Kommando TutHallo.Welt und lassen Sie es
duls aktiviert werden können. Die Aktivierung kann auf mehrere Weisen erfolgen, eine sehr einfache be- ausführen (Menü Dev ! Execute). Sie erhalten im Log-Fenster die Meldung command error: command
steht darin, (nach erfolgreicher Kompilation des Moduls) das Kommando innerhalb der Component Pascal Welt not found in TutHallo, das Kommando Welt ist vom Modul TutHallo nicht exportiert. Fügen Sie im
Umgebung an beliebiger Stelle in ein Textfenster zu schreiben, es zu markieren und im Menü Dev das Prozedurkopf PROCEDURE Welt; zwischen dem Prozedurnamen Welt und dem Semikolon die Export-
Kommando Execute anzuklicken. marke * ein und lassen Sie das Modul erneut kompilieren, im Log-Fenster erscheint compiling Welt is new
Mit Kommandos oder anderen von einem Modul exportierten Bezeichnern ist es ähnlich wie mit in symbol file 32 0, das Kommando TutHallo.Welt ist exportiert.
menschlichen Namen, zur vollständigen Identifikation eines Menschen wird nicht nur sein Vorname, son- Lassen Sie nun das (markierte) Kommando TutHallo.Welt erneut ausführen, so erhalten Sie die selbe
dern auch der Nachname gebraucht. In Component Pascal ist der Nachname eines exportierten Bezeichners Meldung command error: command Welt not found in TutHallo wie zuvor. Dies liegt daran, daß sich das
der Name des exportierenden Moduls, allerdings ist die Reihenfolge der beiden Namensteile vertauscht ursprüngliche Modul (ohne exportiertes Kommando Welt) weiterhin im Arbeitsspeicher befindet. Um das
und statt eines Leerzeichens steht zwischen den Namensteilen ein Punkt. Folglich lautet der vollständige neu kompilierte Modul zu laden, müssen Sie das alte Modul aus dem Speicher entfernen (Dev ! Unload).
Name des Kommandos TutMorgenstern.Start und muß zur Aktivierung in dieser Form benutzt werden. Im Log-Fenster erscheint der Text TutHallo unloaded. Lassen Sie das Kommando TutHallo.Welt danach
Schreiben Sie also das Kommando in das Log-Fenster oder unter den Programmtext, markieren Sie es und erneut ausführen, erscheint im Log-Fenster der Text Hallo Welt, das neu kompilierte Modul ist wieder ge-
laden und das Kommando TutHallo.Welt ist ausgeführt worden.
Harro von Lavergne COMPONENT PASCAL - Ein Tutorium10 KAPITEL 1 - COMPUTERPROGRAMME KAPITEL 2 - GRUNDLAGEN 11
KAPITEL 2
GRUNDLAGEN
2.1. Ausgabeanweisungen
Betrachten Sie das nächste Programm, Text.odc. Laden Sie das Modul, kompilieren Sie es und lassen
Sie das Kommando TutText.Start ausführen. Das Ergebnis ist inhaltsreicher als im vorangegangenen Fall,
im Log-Fenster erscheint, wie bereits bei dem Modul TutMorgenstern, ein etwas längerer Text. Diesmal
sollen Sie sich allerdings weniger um den Inhalt kümmern, als vielmehr um die Frage, durch welche An-
weisungen dieser Text auf den Bildschirm gebracht wird. Zunächst finden Sie die aus dem vorigen Pro-
gramm bekannten Schlüsselwörter MODULE und END wieder. Als Namen des Moduls finden Sie das
Wort TutText, es weist auf den Programmzweck hin, es soll ein Text geschrieben werden.
An dieser Stelle möchte ich einige allgemeine Anmerkungen zu Modulnamen einfügen. Unter Be-
rücksichtigung der weiter oben erwähnten Einschränkungen können Sie als Namen grundsätzlich jede Zei-
chenkombination wählen, die Ihnen in den Sinn kommt. Modulnamen sollten aber soweit möglich den
Hauptzweck des jeweiligen Moduls erkennen lassen. Das nützt dem Leser, während der Compiler sich ver-
ständlicherweise nicht darum kümmert, welche Zeichenkette er an der Stelle des Namens findet, sofern
diese formal korrekt ist.
Weiter hat der Name eines Moduls nichts mit dem Dateinamen zu tun, unter dem das Modul in Ihrem
Computer abgespeichert ist, Sie können als Modulnamen Hinze, als Dateinamen Kunze wählen. Es hat sich
aber als sinnvoll erwiesen, den Modulnamen auch als Dateinamen zu wählen, der Dateiinhalt ist dadurch
unmittelbar ersichtlich. Ich habe das als Regel in diesem Tutorium befolgt; darüber hinaus habe ich die Da-
teinamen (zusammen mit den Kapitelreferenzen) der Deutlichkeit wegen als Kommentare am Anfang der
Programmtexte eingefügt.
Eine Besonderheit der Namensgebung besteht darin, daß das Modul (wie alle bisherigen Module) im
Modulnamen die Vorsilbe Tut besitzt. Diese dient dazu, für den Leser und für das BlackBox System das
Modul als zu einem gemeinsamen Projekt, diesem Tutorium, gehörend kenntlich zu machen. Auf Grund
der Vorsilbe besitzt BlackBox die Möglichkeit, alle Module des Projekts in einem Unterverzeichnis des
Arbeitsverzeichnisses zu sammeln, das diese Vorsilbe als Namen hat. Wie Sie vielleicht beim Kompilieren
des ersten Moduls (Programm A.odc) gemerkt haben, legt BlackBox ein entsprechendes Unterverzeichnis
und die darin benötigten weiteren Unterverzeichnisse von sich aus an, sofern sie nicht existieren. Automa-
tisch angelegt werden beim Kompilieren zwei Verzeichnisse, Code und Sym. Das Verzeichnis Code enthält
alle vom Compiler erzeugten ausführbaren Dateien, die die Endung (Extension) .ocf erhalten und im Ver-
Harro von Lavergne COMPONENT PASCAL - Ein Tutorium12 KAPITEL 2 - GRUNDLAGEN 2.1. Ausgabeanweisungen 13
zeichnis Sym werden die entsprechenden, ebenfalls vom Compiler erzeugten Symboldateien, die die Ein für Bildschirmausgaben geeignetes einfaches Bibliotheksmodul ist das Modul Out. Verständli-
Schnittstellenbeschreibungen des jeweiligen Moduls enthalten, mit der Endung .osf gespeichert. cherweise weiß der Compiler von der Existenz dieses (oder irgendeines anderen) Moduls nichts, das Mo-
Zu einer vollständigen Projektumgebung gehören nach BlackBox Konvention außerdem die Ver- dul Out muß ihm durch eine Importanweisung bekannt gemacht werden. Die Importanweisung ist stets die
zeichnisse Docu, Mod und Rsrc. Das Verzeichnis Docu ist dazu gedacht, die zum Projekt gehörende Doku- erste Anweisung nach dem Modulkopf. Das entsprechende Schlüsselwort heißt IMPORT, ihm folgt die
mentation aufzunehmen, Mod enthält die Quelldateien des Projekts (das auch Untersystem genannt wird), Auflistung der zu importierenden Module, abgeschlossen durch ein Semikolon.
soweit diese öffentlich gemacht werden sollen und in Rsrc (Resource) werden alle innerhalb des Un- Als nächstes enthält das Modul TutText die Ihnen inzwischen vertraute Kommandoprozedur Start. In
tersystems benötigten Hilfsdateien gespeichert ( auf die Einzelheiten wird später genauer eingegangen wer- dieser finden Sie nach dem Schlüsselwort BEGIN die Anweisung, die Schreiben von Text durch das Modul
den; eine ausführliche Darstellung der Zusammenhänge können Sie im Hilfeteil des BlackBox Systems Out ermöglicht, sie lautet Out.String. Grundsätzlich muß alles, was von der Out.String Anweisung erfaßt
unter Documentation Conventions finden). werden soll, in runde Klammern eingeschlossen werden. Text muß außerdem innerhalb der Klammern
Das beschriebene Verfahren bietet eine bequeme Möglichkeit, zusammengehörige Daten eines Pro- zwischen Anführungszeichen gesetzt werden. Alles, was zwischen den Anführungszeichen steht (also
jektes an einer einzigen Stelle zu konzentrieren. Um den Mechanismus benutzen zu können, müssen Sie weder diese selber noch die Klammern oder die Anweisung Out.String), wird dann auf dem Bildschirm
allerdings folgende Regeln beachten. Das automatisch vom BlackBox System angelegte Projektverzeichnis ausgegeben. Auch Leerzeichen sind, wie man am Klammerinhalt der ersten Out.String Anweisung bereits
erhält als Namen die gemeinsame Projektvorsilbe der Module. Alle zum Projekt gehörenden Module müs- sieht, möglicher Text. Die Out.String Anweisung wird (wie jede andere Anweisung) durch ein Semikolon
sen also mit dieser Vorsilbe beginnende Namen erhalten, wobei der erste Buchstabe des Namens ein Groß- beendet.
buchstabe sein muß. Als Vorsilbe identifiziert BlackBox alle darauf folgenden (zugelassenen) Zeichen bis Der auszugebende Text wird nun Zeichen für Zeichen in das Log-Fenster geschrieben, womit eine im
zum nächsten Großbuchstaben. Der gesamte Modulname TutText besteht somit aus der Vorsilbe (dem Prinzip endlose Textzeile entsteht. Um eine derartige Zeile zu beenden, also wie bei einer Schreibmaschine
Präfix) Tut und dem eigentlichen Modulnamen Text. Die vom Compiler erzeugten Code- und Symbol- an den Anfang einer neuen Zeile zu gehen, gibt es eine besondere Anweisung, die sich in der auf die
dateien werden ohne die Vorsilbe Tut in den Unterverzeichnissen Code und Sym des Verzeichnisses Tut als Out.String Anweisung folgenden Zeile findet, sie lautet Out.Ln, wieder gefolgt von einem Semikolon. Ln
Text.ocf und Text.osf gespeichert. Wollten Sie, was in Ihrer zukünftigen Programmierarbeit ebenfalls vor- ist eine Kurzform des englischen Wortes "Line", weshalb es auch so gesprochen wird und steht hier nicht
kommen wird, die Quelltextdatei ebenfalls entsprechend den BlackBox Konventionen speichern, müßte im Sinne von Linie, sondern Zeile(nwechsel). Die Anweisung Out.Ln hat keine Klammern, da es nichts
dies im Fall des Moduls TutText im Verzeichnis Tut/Mod unter dem Namen Text.odc geschehen, also gibt, was in die Klammern zu setzen wäre, denn es gibt nur die Anweisung: Gehe an den Anfang der näch-
ebenfalls ohne die Vorsilbe Tut (da das BlackBox System auf mehreren Plattformen mit unterschiedlichen sten Zeile.
Namenskonventionen eingesetzt werden kann, gilt für die Schreibweise von Pfadnamen generell die Warum macht eine Out.String Anweisung das beim Erreichen des Semikolons nicht automatisch? Der
Internet/Unix-Konvention, bei der ein ' / ' als Separator in Pfadnamen verwendet wird). Grund findet sich in den beiden folgenden Zeilen des Programms. Es gibt Gelegenheiten, bei denen möchte
Ein Letztes zu den Dateinamen. Sie finden bei allen Quelltext-Dateinamen die Extension .odc, bei den man unmittelbar hinter dem Ende des von einer vorangegangenen Ausgabeanweisung geschriebenen
Codedateien die Extension .ocf und bei den Symboldateien die Extension .osf. Diese dienen einfach als Textes mit dem Schreiben fortfahren. Dazu muß das sogenannte Caret (die Schreibmarke, auch Cursor ge-
Hinweis darauf, daß es sich um Component Pascal Dateien handelt. BlackBox hat dadurch die Möglich- nannt), am Ende des eben ausgegebenen Textes verharren, also nicht in die nächste Zeile gehen, obwohl
keit, diese Dateien als Component Pascal Dateien zu identifizieren und automatisch in die Systemumge- die vorangegangene Out.String Anweisung durch das Semikolon beendet war. Die folgende Out.String
bung zu laden. Anweisung schreibt dann ihren Inhalt fortlaufend ab der aktuellen Caret-Position in die selbe Zeile, die
Der Name der vorliegenden Datei, Text.odc, signalisiert also, daß es sich um ein Component Pascal insgesamt durch eine Out.Ln Anweisung abgeschlossen werden kann. Vor dieser Out.Ln Anweisung ent-
Programm handelt, mit dem ein Text auf den Bildschirm geschrieben werden soll. Die Ausgabe von Text, steht also trotz zweier unmittelbar aufeinander folgender Out.String Anweisungen ein fortlaufender Text
Zahlen oder anderen Zeichenfolgen ist in Component Pascal nicht Aufgabe der Programmiersprache, son- ohne Zeilensprünge.
dern wird von verschiedenen sogenannten Bibliotheksmodulen durchgeführt. Bibliotheksmodule sind Mo- Im Programm folgt nun der Out.Ln Anweisung unmittelbar eine weitere, die prinzipiell das Gleiche
dule, die in der BlackBox Systemumgebung existieren und verschiedene, für die Ausführung von Compo- wie die vorige tut, sie beendet die aktuelle Zeile und geht an den Anfang der nächsten. Da in die aktuelle
nent Pascal Programmen häufig benötigte Dienste zur Verfügung stellen. Zeile aber in der Zwischenzeit nichts hineingeschrieben wurde, erzeugt die zweite Out.Ln Anweisung eine
Harro von Lavergne COMPONENT PASCAL - Ein Tutorium14 KAPITEL 2 - GRUNDLAGEN 2.2. Kommentare 15
Leerzeile. Sie haben, wie Sie sehen, auf diese Weise eine einfache Möglichkeit, eine Textausgabe zu der Bildschirmausgabe zunächst, daß es sich bei Kommentaren um Programmtext handelt, der vom Com-
gliedern. Die folgenden drei Out.String Anweisungen werden folglich vom Compiler zusammenhängend piler ignoriert wird. Das ist keineswegs selbstverständlich, denn wenn Sie irgend ein von Ihnen als Kom-
in eine Zeile geschrieben und als letztes gibt es durch die Out.Ln Anweisung einen Zeilenvorschub. mentar gedachtes Wort in den Modultext schreiben, auch wenn Sie es in Klammern setzen, wird der Com-
In den letzten drei Out.String Anweisungen finden Sie eine wichtige Änderung. Die zweite dieser Zei- piler mit einer Fehlermeldung reagieren. Er versucht, dieses Wort als Information, als Befehl zu erkennen
len verwendet wie bisher als Textkennung für den Compiler die Anführungszeichen, der Apostroph im Ge- und scheitert.
nitiv Hans' wird wie alle anderen Zeichen behandelt und auf dem Bildschirm ausgegeben. In den anderen Zum Erkennen eines Kommentars erwartet der Compiler ein entsprechendes Signal. Kommentare
beiden Out.String Anweisungen sollen aber die Anführungszeichen als Kennzeichnung der wörtlichen werden in Component Pascal durch die Zeichenfolge (* *) gekennzeichnet, wobei der eigentliche Kom-
Rede darzustellende Textzeichen sein, nicht Textkennungen für den Compiler. Was also tun? In Compo- mentartext zwischen diesen Klammern steht. Sie sehen an dem Modul TutKomment, daß Kommentare an
nent Pascal gibt es für diesen Fall eine zweite Möglichkeit der Textkennung, die den auszugebenden Text fast beliebiger Stelle auftauchen können, vor dem Anfang des eigentlichen Programms ebenso wie nach
einschließenden Anführungszeichen können durch Apostrophe (von manchen Menschen Hochkommata seinem Ende, aber auch an praktisch jeder Stelle innerhalb der Deklarationen und Anweisungen.
genannt) ersetzt werden. Allerdings können diese Kennungszeichen nicht gemischt verwendet werden, die Für die Programmierarbeit nützlich ist vor allem eine spezielle Möglichkeit des Kommentierens, näm-
den Text einleitenden und schließenden Zeichen müssen übereinstimmen. lich die Möglichkeit des Kommentars innerhalb eines Kommentars. Dies wird für Sie wichtig, wenn Sie
später einmal ein fehlerhaftes Programm verbessern wollen, wobei sie möglicherweise mehrere Fehlermel-
dungen "gleichzeitig" zu bearbeiten haben. Oft ist es in solchen Fällen das Sinnvollste, sich jedem Fehler
2.2. Kommentare einzeln zuzuwenden. Programmteile, die andere Fehler enthalten, müssen also aus dem Programm "ent-
fernt" werden. Natürlich wollen Sie diese Teile nur für den Augenblick, für die Dauer der Beschäftigung
Sie werden wahrscheinlich ebenso wie ich schon die Erfahrung gemacht haben, daß Sie Ihre eigenen mit dem gerade betrachteten Fehler ignorieren. Die entsprechenden Programmteile sollen also nicht wirk-
Aufzeichnungen zu einem Gedankengang, der Sie früher einmal beschäftigt hat und der Ihnen damals völ- lich entfernt, sondern nur vor dem Compiler versteckt werden. Dies läßt sich dadurch erreichen, daß Sie
lig klar gewesen ist, bei späterer Lektüre für unverständlich hielten, daß wesentliche Teile Ihrer Gedanken die jeweiligen Abschnitte des Programms "wegkommentieren". Dabei kann es nun sein, daß ein derartiger
in diesen Aufzeichnungen nicht festgehalten waren, kurz, daß alles, was Sie dazu noch besitzen, unbrauch- Abschnitt bereits einen Kommentar enthält. Die Möglichkeit, einen Kommentar zu schreiben, der einen
bar geworden ist. Andererseits können die Aufzeichnungen durchaus noch alles Wesentliche enthalten, sie Kommentar enthält, vereinfacht in solchen Fällen die Arbeit wesentlich.
sind nur so unübersichtlich, daß es Ihnen trotz intensiver Arbeit nicht mehr gelingt, ihren Inhalt zu verste-
hen. Im ersten dieser beiden Fälle fehlt offensichtlich der erläuternde Text, der Ihre Notizen erst nachvoll-
ziehbar macht, im zweiten Fall fehlt eine Strukturierung, die alles soweit gliedert, daß es verständlich wird. 2.3. Die Form eines Programms
Bleiben wir bei dem ersten Fall. Gerade ein Computerprogramm mit seinen starren, floskelhaften Be-
fehlen gerät schnell in Gefahr, für den Leser unbegreiflich zu sein. Auf Grund dieser Erfahrung bietet Der zweite der beiden oben erwähnten Gründe, einen Text oder ein Programm für unverständlich zu
Component Pascal als Gegenmittel die Möglichkeit, durch Kommentare Erläuterungen in den Programm- halten, lag im Fehlen einer angemessenen Strukturierung der Informationen, sie waren allzu unübersicht-
code einzufügen. Sie sollten die Wirksamkeit solcher Kommentare nicht unterschätzen und so früh wie lich. Sehen Sie sich das Programm Formvoll.odc an. Auch mit dem Wenigen, das Sie bisher gelernt haben,
möglich anfangen, Ihre eigenen Programme durch Kommentare zu ergänzen, damit ein Leser in die Lage werden Sie ohne Mühe erkennen, was das Modul tut und wie die Bildschirmausgabe aussehen wird. (Ver-
versetzt wird, den Zweck des Programms und seiner Teile problemlos zu verstehen; Sie sollten ihm, dem suchen Sie bitte, diese tatsächlich vorherzusagen. Schreiben Sie am besten auf, was Ihrer Meinung nach im
Leser, letztlich durch die Kommentare ermöglichen, das Programm selbst zu nutzen und weiterzuent- Log-Fenster erscheinen wird, und vergleichen Sie anschließend mit der realen Ausgabe. Beachten Sie
wickeln. dabei insbesondere den Unterschied zwischen Leerzeichen, die im Programmcode stehen und der Gliede-
Laden Sie das Programm Komment.odc, lassen Sie es kompilieren und ausführen. Viel wird es Ihnen rung des Druckbildes dienen und Leerzeichen, die zwischen Anführungszeichen erscheinen, also von einer
nicht auf den Bildschirm schreiben, es ist gerade nicht zu diesem Zweck gedacht. Es zeigt Ihnen vielmehr, Out.String Anweisung erfaßt werden und deshalb in der Bildschirmausgabe des Programms erscheinen.)
wo und in welcher Weise Sie Kommentare in Programme einfügen können. Sie ersehen aus der Kargheit
Harro von Lavergne COMPONENT PASCAL - Ein Tutorium16 KAPITEL 2 - GRUNDLAGEN KAPITEL 3 - Einfache Datentypen 17
Sehen Sie sich als nächstes das Programm Formlos.odc an. Es bedarf wahrscheinlich einer erheb- KAPITEL 3
lichen Mühe, möglicherweise eines völligen Neuschreibens des Modultextes, um über die Bildschirmaus-
gabe sicher zu sein. Tatsächlich ist diese identisch mit der des Moduls TutFormvoll, wie Sie merken wer- EINFACHE DATENTYPEN
den, wenn Sie die Kommandoprozeduren TutFormvoll.Start und TutFormlos.Start ausführen lassen; ja, bis
auf die Anzahl und die Verteilung der Leerzeichen innerhalb des Programms sind auch alle Anweisungen
beider Programme identisch. 3.1. Konstanten und Variablen
Sie sehen, wie wichtig für die Benutzung - durch Menschen, nicht durch die Maschine - die Form und
die Darbietung des eigentlichen Programmcodes ist. Versuchen Sie von Anfang an, Ihre Programme in Auch wenn ein Programm üblicherweise nichts mit Mathematik zu tun hat, geht es in Component
einer übersichtlichen Weise zu formatieren und durch Kommentare lesbar zu gestalten. Denken Sie dabei Pascal (zum Trost: auch in jeder anderen Programmiersprache) nicht ganz ohne sie, denn die internen Ma-
daran, daß nicht nur Sie Ihre Programme später verstehen und "schön" finden wollen, sondern daß andere schinenoperationen beruhen auf mathematischer Logik; aber es handelt sich bei dem Folgenden, soviel sei
sie lesen und möglichst problemlos verstehen wollen und sollen. versprochen, um einfache Grundrechnungsarten. Wichtig ist allerdings, daß Sie die Einzelheiten dieses Ka-
Einige Formatierungsregeln können Sie bereits jetzt den bisher durchgearbeiteten Programmen ent- pitels wirklich durcharbeiten und verstehen; alles Spätere wird sich auf die eine oder andere der hier erar-
nehmen. Zusammengehörende Programmteile sollten Sie dadurch kenntlich machen, daß Sie diese gegen- beiteten Grundlagen stützen und davon Gebrauch machen.
über ihrem Anfang und Ende nach rechts einrücken, wobei sich eine Verschiebung um einen Tabulator- Laden Sie das Programm ConstVar.odc. Es ist das erste Programm, das Aussagen zwischen der Kopf-
schritt als übersichtlich bewährt hat. In den bisherigen Programmen sind solche zusammengehörigen Teile zeile der Prozedur Start und dem Schlüsselwort BEGIN enthält. Dieser Teil der Prozedur wird Deklara-
die Befehle, die der Anweisungsteil der Ausgabeprozeduren Start enthält, alles also, was zwischen BEGIN tionsteil genannt, der dem BEGIN folgende Teil heißt Anweisungsteil, in ihm stehen alle Handlungsanwei-
und END erscheint. Andere derartig gliedernde Einrückungen werden Sie in späteren Programmen kennen- sungen für den Compiler, während im Deklarationsteil all das steht, was späterhin im Anweisungsteil als
lernen. "Zutat" des "Kuchens" erscheinen soll, denn eine Grundregel in Component Pascal besagt, daß alles vorab
Eine weitere Component Pascal Formatierungsregel besagt, Kommentare in Kursivschrift zu schrei- deklariert, also dem Compiler bekannt gemacht werden muß, was später verwendet werden soll.
ben, Sie haben dies im Programm Komment.odc gesehen. Eine dritte Regel, die Sie in den bisherigen Pro- Als erstes sehen Sie im Deklarationsteil ein neues Component Pascal Schlüsselwort: CONST. Damit
grammen ebenfalls schon gesehen haben, heißt, exportierte Bezeichner in Fettdruck zu schreiben (eine aus- wird dem Compiler erklärt, daß die nachfolgenden Bezeichner Konstanten sind, Ausdrücke also, deren
führliche Darstellung der Formatierungsregeln können Sie im Hilfeteil des BlackBox Systems unter Pro- Werte für den Gültigkeitsbereich der Prozedur dauerhaft festgelegt sind. Die Zeile: Titel = "Konstanten
gramming Conventions finden). und Variablen" identifiziert für den Compiler den Bezeichner Titel mit dem Inhalt Konstanten und Varia-
Wie schon in den vorangegangenen Programmen finden Sie in der Zeile ! TutFormlos.Start unter- blen. Ebenso identifiziert die folgende Zeile: z = -2 den Bezeichner z mit der Zahl -2.
halb des Moduls dessen ausführbares Kommando. Zusätzlich finden Sie vor dem Kommandotext das Sym- Im Gegensatz zum Schlüsselwort CONST steht das anschließende Schlüsselwort VAR. Damit wird
bol ! , mit dem Ihnen das BlackBox System eine angenehme Arbeitserleichterung zur Verfügung stellt. dem Compiler erklärt, daß die nachfolgenden Bezeichner x, y und Summe Variablen sind, Größen also,
Statt den Text zu markieren und anschließend den Menüpunkt Dev ! Execute aufzurufen, genügt es, auf deren Werte im Laufe des Programms geändert werden können. Während jedoch die Werte von Konstan-
diese "Kommandoschaltfläche" (Englisch: commander) zu klicken; BlackBox liest daraufhin den an- ten durch die oben beschriebene Identifikation unmittelbar bei der Deklaration festgelegt werden, sind die
schließenden Text und führt, sofern es sich um ein Kommando handelt, dieses aus. Wenn Sie bei Ihrer zu- Anfangswerte von Variablen nicht bereits bei der Deklaration bestimmt, sondern sie werden den Variablen
künftigen Programmierarbeit einen derartigen commander verwenden wollen, können Sie die Schreib- erst im Anweisungsteil der Prozedur zugewiesen (und eventuell ein- oder mehrmals verändert).
marke vor den Kommandotext setzen und die Kommandoschaltfläche mit Tools ! Insert Commander Darüber hinaus ist ein Weiteres bei der Deklaration von Variablen wichtig. Der Computer hat für Da-
einfügen. ten verschiedenen Typs sehr unterschiedliche Erkennungs- und Verarbeitungsmechanismen. Für Sie wird
es wahrscheinlich keinen großen Unterschied zwischen der ganzen Zahl 2 und der Dezimalzahl 2.0 geben,
aber für den Computer ist er erheblich. Ihm muß also bei der Variablendeklaration mitgeteilt werden, wel-
ches der sogenannte Datentyp jeder Variablen ist. Diese Mitteilung geschieht durch den Doppelpunkt
Harro von Lavergne COMPONENT PASCAL - Ein Tutorium18 KAPITEL 3 - Einfache Datentypen 3.1. Konstanten und Variablen 19
hinter dem (oder den, durch Komma getrennten) Variablennamen; auf den Doppelpunkt folgt dann die Stelle geschehen. Bei einer Wertzuweisung, die ihrerseits auf der rechten Seite des Zuweisungszeichens
Typangabe. In diesem Modul finden Sie den Datentyp INTEGER, andere werden bald folgen 2. Unter dem Variablen enthält, müssen Sie darauf achten, daß jeder einzelnen der rechts stehenden Variablen vorher ein
Datentyp INTEGER sind alle ganzen Zahlen zu verstehen, also die Zahlen: ... -2; -1; 0; 1; 2; ... u.s.w. Sie Wert zugewiesen wurde, anderenfalls sind die Ergebnisse unvorhersehbar, die Folgen eventuell fatal.
sehen an dem Programm, daß Variablen sowohl einzeln als auch in Gruppen deklariert werden können, so- Falls Sie jetzt Schwierigkeiten haben mit dem Unterschied, der zwischen einer Variablen und dem
fern sie vom selben Typ sind, es ist ein Teil der Stilfrage, wie man diese Aufteilung vornimmt. Wert besteht, den die Variable enthält, grämen Sie sich nicht, das geht vielen Menschen an dieser Stelle so.
Eine Anmerkung zur Konstantendeklaration. Im Gegensatz zu dem, was bei Variablen gesagt war, Die Schwierigkeit wird sich im Lauf Ihrer weiteren Arbeit ganz sicher auflösen, vielleicht hilft Ihnen auch
muß für eine Konstante keine Typangabe erfolgen, denn der Compiler erkennt aus der Notationsform der die folgende Erklärung ein wenig weiter.
Größe, die dem Gleichheitszeichen folgt, um welchen Datentyp es sich handelt. So hat in der oben an- Stellen Sie sich den ganzen Computer als einen Schrank mit einem Mechanismus vor, der im Innen-
geführten Deklaration CONST z = -2 der Bezeichner z den Datentyp INTEGER, die Deklaration raum Dinge hin- und herschiebt und miteinander verknüpft. Der Mechanismus heißt amerikanisch Central
CONST z = -2.0 dagegen würde den Typ von z als REAL, also als Dezimalzahl festlegen (zum Datentyp Processing Unit (abgekürzt CPU) und der Raum heißt Arbeitsspeicher. Sie denken sich diesen am besten
REAL s. Programm 3 dieses Kapitels: RealMath.odc). Entsprechend erhält der Bezeichner Titel durch die als eine große Menge von numerierten Schubladen, in die man etwas hineinlegen kann. Die Deklaration
bei der Deklaration erfolgte Identifikation mit einem Textstück (einer Folge von Schriftzeichen) den Da- einer Konstanten, beispielsweise z, erfolgt nun in der Weise, daß der "kleine Mann" im Computer eine dem
tentyp "String" (Zeichenkette, exakt heißt der Datentyp nicht "String", sondern ARRAY OF CHAR; zur De- Datentyp der Konstanten entsprechende Schublade aussucht, die ein Etikett mit der Aufschrift: "Unver-
finition s. das Programm 7.5, String.odc). änderbar" erhält. In die Schublade legt er den Wert von z, die Zahl -2. Bei einer Variablendeklaration
Sehen Sie sich nun den Anweisungsteil der Prozedur Start an. Beim Durchlesen wird er Ihnen, bis auf schreibt er auf die entsprechende Schublade die Bemerkung: "Inhalt veränderbar", außerdem den zugehöri-
wenige Einzelheiten, unmittelbar klar sein, zumindest werden Sie verstehen, was die Prozedur tut. Sie fin- gen Datentyp. Zu diesem Zeitpunkt muß die richtige Schubladenart gewählt werden, daher muß bei der
den dort einige Out.Ln und eine ganze Reihe von Out.String Anweisungen, die Sie inzwischen kennen. Anbringung des Aufklebers der Datentyp des künftigen Inhalts bereits festgelegt worden sein. In die
Dagegen sind die Ausgabeanweisungen Out.Int(x, 4), Out.Int(y, 4), Out.Int(z, 4) und Out.Int(Summe, 4) Schublade hinein kommt im Moment noch nichts, das geschieht erst im Anweisungsteil durch die entspre-
neu für Sie. chende Zuweisung.
Außerdem finden Sie gleich zu Beginn drei sogenannte Zuweisungen. Die erste lautet x := 12. Das In einer Art Liste vermerkt der "kleine Mann" die Nummern der Schubladen und die zugehörigen Na-
(zusammengesetzte) Zeichen := ist in Component Pascal ein reservierter (Schlüssel-) Bezeichner. Es heißt men. Da das Ganze sehr einem Eintrag in ein Adressenverzeichnis ähnelt, heißt die Speicherstelle im Com-
Zuweisung, und tut genau das, was der Name sagt. In diesem Falle weist es der Variablen x den Wert 12 puter auch ADRESSE; der Eintrag in die Adressenliste verbindet also einen Namen und die zu diesem Na-
zu (gesprochen wird dies am besten in folgender Weise: "x werde 12"). In einer Zuweisung steht der zuge- men gehörende Adresse - die "Schublade" - in der sich der zum Namen gehörende Wert befindet. Wie für
wiesene Wert immer rechts vom Zuweisungszeichen := und die Variable, der dieser Wert zugewiesen die Schublade das Wort ADRESSE, so gibt es auch für den Aufkleber der Schublade einen besonderen Na-
wird, stets auf der linken Seite. x ist eine Variable, weil sie als solche deklariert wurde, und sie mußte so men, er wird TYPDESCRIPTOR genannt.
deklariert werden, weil links vom Zuweisungszeichen := nur eine Variable stehen darf, da die Zuweisung Zurück zu den oben kurz erwähnten Ausgabeanweisungen der Form Out.Int(, ). Die vorstehende Ausgabeanweisung besagt, daß das Modul Out mit der Anweisung Out.Int eine
In gleicher Weise werden in den folgenden Schritten den beiden Variablen y und Summe Werte zu- ganze Zahl, also eine Zahl des Typs INTEGER ausgibt. Beachten Sie bitte, daß das x bei der Anweisung
gewiesen. Bei der Zuweisung an die Variable Summe sehen Sie, daß einer Zahlvariablen nicht nur feste Out.Int(x, 4) innerhalb der Klammern nicht in Anführungszeichen oder Apostrophe eingeschlossen ist.
Werte, sondern auch arithmetische Ausdrücke aus Variablen und Konstanten zugewiesen werden können. Folglich interpretiert der Compiler dies x nicht als Text, sondern erkennt es als die zuvor deklarierte Varia-
Solche Ausdrücke werden vor der Zuweisung berechnet. Wichtig ist dabei, daß Wertzuweisungen an Va- ble x. Die Anweisung Out.Int(x, 4) bedeutet deshalb, daß der aktuelle Wert der Variablen x ausgegeben
riablen nicht gleich zu Beginn des Anweisungsteils erfolgen müssen, sie können an jeder gewünschten werden soll, das also, was in der "Schublade" des Arbeitsspeichers liegt. In diesem Fall ist das die zuvor
zugewiesene Zahl 12. Entsprechendes gilt für y und z sowie für die Variable Summe, der zuvor das Ergeb-
nis der Berechnung von x+y+z-3 zugewiesen wurde, also die Zahl 20. Der Bezeichner der jeweiligen gan-
2
zen Zahl - im Modul TutConstVar sind dies die Konstante z und die Variablen x, y, Summe - steht in den
Eine Zusammenstellung der in Component Pascal vordefinierten Datentypen finden Sie im Anhang B.
Harro von Lavergne COMPONENT PASCAL - Ein Tutorium20 KAPITEL 3 - Einfache Datentypen 3.2. Ganzzahlmathematik 21
Klammern der Ausgabeanweisung stets an erster Stelle, als Zweites benötigt Out.Int innerhalb der Klam- alle Datentypen feste Größen vereinbart, so daß mit der Deklaration des Typs einer Variablen der Spei-
mern die Angabe einer Feldlänge, wobei diese von der auszugebenden Zahl durch ein Komma getrennt cherbedarf und die maximale Größe der möglichen Variablenwerte festliegen.
wird. Die ist eine ganze Zahl und gibt an, wie viele Stellen die Ausgabe der Zahl mindestens Nun können Zahlen manchmal sehr groß sein (z. B. 1000000000000000000000000000), der Spei-
haben soll, Out.Int( x, 4) sorgt also dafür, daß der (aktuelle) Wert der Variablen x, hier die Zahl 12, in ein cherplatz für eine Zahlvariable, die eine solche Zahl speichern kann, wäre unnötig groß dimensioniert,
Ausgabefeld der Länge 4 geschrieben wird. Der Wert der Variablen wird rechtsbündig in das Feld einge- wenn in einem Programm tatsächlich nur Zahlen vorkommen, die nicht größer als beispielsweise 1000000
tragen, die nicht benötigten vorangehenden Stellen werden mit Leerzeichen gefüllt. Am Beispiel bedeutet sind. Daher gibt es für die Ganzzahlvariablen mehrere Typen, die im Sinne der mathematischen Inklusion
dies, daß vor der 12, die zwei Stellen des Feldes belegt, zwei Leerzeichen eingefügt werden. eine Größenhierarchie bilden: BYTE d SHORTINT d INTEGER d LONGINT. Die in dieser Hierarchie
Nun entsteht bei Ihnen wahrscheinlich die Frage, was geschieht, wenn die gesamte auszugebende weiter rechts stehenden Zahltypen umfassen alle links von ihnen stehenden Typen 3. Der kleinste Zahltyp,
Zahl länger ist als die vordefinierte Feldlänge. Keine Sorge, die Zahl wird nicht verstümmelt, in dieser Si- BYTE, enthält alle ganzen Zahlen zwischen -128 und +127, die kleinste BYTE-Zahl ist also -128 und die
tuation schafft der Compiler selbsttätig den benötigten Platz, die eventuell nachfolgende Ausgabe wird größte ist +127. Die Konsequenzen der eben beschriebenen Hierarchisierung werden Sie weiter unten im
nach hinten verschoben. Eine von Ihnen erdachte Anordnung der einzelnen Zahlen geht allerdings verlo- Programm kennenlernen.
ren, da sich alle weiteren ausgegebenen Daten entsprechend verschieben. Bitte denken Sie daran, daß mit den Deklarationen nur die Konstante c, nicht jedoch irgendeine der
Variablen einen Wert enthalten, daß man mit diesen also noch keine Operationen durchführen kann. Der
Anweisungsteil der Prozedur Start, der dem Schlüsselwort BEGIN folgt, weist dementsprechend als erstes
3.2. Ganzzahlmathematik den Variablen I und J jeweils einen Wert zu. In der ersten Anweisung wird der Variablen I einfach die kon-
stante Zahl 9 zugewiesen. In der zweiten Anweisung erhält die Variable J das Ergebnis einer Berechnung
Ich sagte schon, daß es für Computer einen wesentlichen Unterschied macht, ob sie sich mit ganzen zugewiesen, bei der zum aktuellen Wert von I, also der Zahl 9, die Zahl 132 und die Konstante c addiert
Zahlen beschäftigen oder mit reellen Zahlen, den Zahlen also, die Sie auch als Dezimalzahlen kennen. Für werden. Das Ergebnis, die Zahl 13, wird in (der "Schublade" mit der Aufschrift) J gespeichert. Die fol-
jede der beiden Zahlarten gibt es deshalb eigene Datentypen, INTEGER und REAL, die Sie in diesem und gende Anweisung berechnet ebenso die Summe der Werte von I und J und weist das Ergebnis der Varia-
dem folgenden Abschnitt kennenlernen werden. blen IntSumm zu. Entsprechendes geschieht in den anschließenden Zeilen mit der Differenz und dem Pro-
Laden Sie das Programm IntMath.odc, das Sie mit den mathematischen Operationen bekannt machen dukt dieser beiden Werte, die Ergebnisse werden den Variablen IntDiff und IntProd zugewiesen.
wird, die für INTEGER Zahlen existieren. Nach dem Modulkopf finden Sie als erstes die Ihnen inzwischen Wenn Sie jetzt zur nächsten Zeile kommen, ist es an der Zeit, einiges zu den Rechenoperationen mit
bekannte Importanweisung für das Modul Out und als nächstes die Ihnen ebenfalls bekannte exportierte INTEGER-Zahlen zu sagen. Die Rechenzeichen + und - kennen Sie sicherlich aus den Anfängen Ihrer
Kommandoprozedur Start. In deren Deklarationsteil sehen Sie die Deklaration einer Konstanten und meh- Schulzeit, sie machen auch in Component Pascal das, was Sie gewohnt sind. Auch das Zeichen * ist Ihnen
rerer Variablen. Die Namen sollten selbsterklärend sein, jedenfalls dann, wenn Sie die Verwendung dieser möglicherweise bereits als Multiplikationsoperator begegnet, soweit gibt es also bisher keine Besonderhei-
Variablen im Anweisungsteil gesehen haben. Während Ihnen der Datentyp INTEGER, der für die Varia- ten. Neu ist für Sie aber wahrscheinlich das Schlüsselwort DIV, das in der folgenden Anweisung erscheint.
blen I, J, IntSumm, IntDiff, IntProd, IntDivi, IntRest deklariert wird, aus dem Modul TutConstVar bekannt Nun werden Sie denken, dies sei eben die Component Pascal Schreibweise für den Divisionsoperator, und
ist, benötigen die Variablendeklarationen B, C: BYTE; S, T: SHORTINT; L, M: LONGINT einige Erläute- das stimmt auch, aber es gibt etwas dabei, das man unbedingt beachten muß. Es handelt sich bei allen hier
rungen. verwendeten Zahlen und den Operationen mit ihnen um ganze Zahlen. Bei der Addition, Subtraktion und
Mathematisch sind zwar die ganzen Zahlen, um die es hier geht, nach oben und unten unbegrenzt. Multiplikation von ganzen Zahlen gibt es insofern keine Probleme, als im Ergebnis wieder ganze Zahlen
Allerdings nimmt die Menge der Ziffern, die zum Notieren immer größerer bzw. kleinerer Zahlen nötig stehen. Anders verhält es sich jedoch mit der uns geläufigen Division, 3 ÷ 4 = 0.75 ist keine ganze Zahl,
werden, dauernd zu. Für Sie und mich und auch für den Computer bedeutet dies, daß irgendwo eine sondern eine Dezimalzahl, in Component Pascal also eine Zahl vom Typ REAL. Der Divisionsoperator
Grenze der Notationsfähigkeit auftaucht. Genau so, wie Sie für das Notieren einer Zahl mit mehr Ziffern
mehr Platz benötigen, benötigt der Computer für solche Zahlen mehr Speicherplatz. Deshalb hat man für
3
Eine zusammenfassende Darstellung aller Zahltypen und ihrer Gültigkeitsbereiche finden Sie im Anhang B.
Harro von Lavergne COMPONENT PASCAL - Ein TutoriumSie können auch lesen
