Turbo Pascal 7.0

Transcription

Turbo Pascal 7.0

84
4URBO0ASCAL
%YXSVIR%,IVHX->MQQIVQERR
JÚV(37
%YJPEKIZSQ2SZIQFIV
F],)6(8:IVPEKJÚV&MPHYRKWQIHMIR+QF,
&SHIRLIMQ
-RXIVRIX[[[LIVHX]SYHIEXGL
[[[LIVHXFYWMRIWWHIEXGL
[[[LIVHXZLWHIEX
84
%PPI 6IGLXI ZSVFILEPXIR /IMR 8IMP HIW ;IVOIW HEVJ MR
MVKIRHIMRIV*SVQ(VYGO*SXSOSTMI1MGVSJMPQSHIVIMRIQ
ERHIVIR :IVJELVIR SLRI WGLVMJXPMGLI +IRILQMKYRK HIW
,IVEYWKIFIVW
VITVSHY^MIVX
IPIOXVSRMWGLIV
7]WXIQI
SHIV
YRXIV
ZIVEVFIMXIX
:IV[IRHYRK
ZIVZMIPJÂPXMKX
SHIV
ZIVFVIMXIX[IVHIR
(MIWI 9RXIVPEKI [YVHI QMX KVS½IV 7SVKJEPX IVWXIPPX YRH
KITVÚJX 8VSX^HIQ OÔRRIR *ILPIV RMGLX ZSPPOSQQIR EYW
KIWGLPSWWIR [IVHIR :IVPEK ,IVEYWKIFIV YRH %YXSVIR
OÔRRIRJÚVJILPIVLEJXI%RKEFIRYRHHIVIR*SPKIR[IHIV
IMRI NYVMWXMWGLI :IVERX[SVXYRK RSGL MVKIRHIMRI ,EJXYRK
ÚFIVRILQIR
(MI &MPHYRKWQIHMIR HIW ,)6(8:IVPEKW IRXLEPXIR 0MROW
F^[ :IV[IMWI EYJ -RXIVRIXWIMXIR ERHIVIV %RFMIXIV %YJ
-RLEPX YRH +IWXEPXYRK HMIWIV %RKIFSXI LEX HIV ,)6(8
:IVPEK OIMRIVPIM )MRJPYWW ,MIVJÚV WMRH EPPIMRI HMI NI[IM
PMKIR%RFMIXIVZIVERX[SVXPMGL
Inhaltsverzeichnis
1.
2.
3.
4.
4.3.
Einführung in Turbo Pascal 7.0 ................4
Die Auswahl (Alternative)........................65
4.3.1.
Einseitige Auswahl ...................67
Zweiseitige Auswahl.................70
1.1.
Die Funktionsweise eines Computers.......4
4.3.2.
1.2.
Algorithmen und Programme ....................6
4.3.3.
Mehrstufige Auswahl ................72
1.3.
Die Programmentwicklung ........................6
4.3.4.
Mehrseitige Auswahl
(Fallauswahl)............................76
1.4.
Die Dateien von Turbo Pascal 7.0 ............7
1.5.
Einordnung der Programmiersprache
Turbo Pascal 7.0 ......................................8
1.6.
Starten von Turbo Pascal 7.0 ...................9
1.7.
Beenden von Turbo Pascal 7.0.................9
4.4.
Die Wiederholung (Iteration) ...................81
4.4.1.
Die zählergesteuerte
Wiederholung...........................82
4.4.2.
Die bedingte Wiederholung ......85
4.5.
Weitere Kontrollstrukturen ......................90
4.6.
Zusammenfassung .................................92
Grundlagen der Bedienung.....................10
2.1.
Der Arbeitsbildschirm .............................10
2.2.
Das Menü ...............................................11
2.3.
Dialogfenster ..........................................12
5.1.
Grundlagen .............................................94
2.4.
Der Editor ...............................................14
5.2.
Selbstdefinierte Prozeduren ....................95
2.5.
Quellprogramme eingeben
und bearbeiten........................................15
5.2.1.
Prozeduren mit globalen
Variablen und Konstanten ........95
2.6.
Quellprogramme speichern
und schließen .........................................18
5.2.2.
Prozeduren mit lokalen
Variablen und Konstanten .......97
2.7.
Quellprogramme laden
bzw. neu erzeugen .................................20
5.2.3.
Prozeduren mit
Wertübergabe ..........................98
2.8.
Compilieren und Starten .........................21
5.2.4.
2.9.
Grundlagen der Fenstertechnik ..............23
Prozeduren mit
Variablenübergabe ...................99
2.10.
Programmteile markieren,
kopieren, löschen und verschieben.........25
2.11.
Letzte Aktion zurücknehmen...................28
2.12.
Suchen und Ersetzen .............................28
2.13.
Quellprogramme drucken .......................31
2.14.
Zusammenfassung .................................31
5.
Prozeduren ...............................................94
5.3.
6.
Vordefinierte Prozeduren ......................103
Funktionen..............................................106
6.1.
Grundlagen ...........................................106
6.2.
Selbstdefinierte Funktionen...................107
6.2.1.
Grundlagen der Programmierung
von Turbo Pascal .....................................32
Funktionen mit globalen
Variablen und Konstanten ......107
6.2.2.
Funktionen mit lokalen
Variablen und Konstanten ......109
3.1.
Der Programmaufbau .............................32
6.2.3.
3.2.
Variablen ................................................36
Funktionen mit
Wertübergabe ........................110
3.3.
Konstanten .............................................39
6.2.4.
Funktionen mit
Variablenübergabe .................112
3.4.
Einführung wichtiger
Standard-Datentypen..............................42
3.5.
Wichtige Sprachelemente.......................47
3.6.
Ein- und Ausgabe ...................................49
3.7.
Syntaxmarkierung in Turbo Pascal .........54
3.8.
Fehlersuche und Fehlerbehebung ..........56
3.9.
Das Hilfesystem von Turbo Pascal .........58
6.3.
7.
Besonderheiten von Funktionen und
Prozeduren .............................................118
7.1.
Reihenfolgekonflikt bei der Definition
von Prozeduren und Funktionen ...........118
7.2.
Geschachtelte Prozeduren und
Funktionen ............................................120
7.3.
Rekursionen..........................................123
7.4.
Offene Parameter .................................125
Kontrollstrukturen ...................................62
4.1.
Grundlagen und
Darstellungsmöglichkeiten......................62
4.2.
Die Folge (Sequenz)...............................64
Vordefinierte Funktionen .......................115
Turbo Pascal 7.0 für DOS
8.
9.
Units
....................................................128
8.1.
Grundlagen ...........................................128
16.1.
Aufgaben des Debuggers..................... 192
8.2.
Selbstdefinierte Units............................128
16.2.
Ausführen einzelner Anweisungen ....... 192
8.3.
Vordefinierte Units ................................131
16.3.
Ausführen von Anweisungsblöcken...... 193
16.4.
Überwachen von Variableninhalten ...... 194
16. Das Arbeiten mit dem Debugger ..........192
Mehr zu den Datentypen .......................132
Anhang: Reservierte Programmierwörter ...196
9.1.
9.2.
9.3.
Weitere numerische Datentypen...........132
Selbstdefinierte Datentypen ..................135
9.2.1.
Grundlagen ............................135
9.2.2.
Aufzählbare Datentypen.........136
9.2.3.
Teilbereichstypen...................138
Strukturierte Datentypen .......................140
10. Tabellenverarbeitung ............................142
10.1.
Grundlagen der Tabellenverarbeitung...142
10.2.
Eindimensionale Tabellen .....................145
10.3.
Zweidimensionale Tabellen...................147
10.4.
Mehrdimensionale Tabellen ..................150
10.5.
Zusammenfassung ...............................153
11. Die Datenstruktur Menge ......................154
12. Die Datenstruktur Verbund ...................160
13. Dateiverarbeitung ..................................164
13.1.
Grundlagen ...........................................164
13.2.
Sequentielle Dateiverarbeitung .............167
13.3.
13.2.1.
Neue Datensätze eingeben....167
13.2.2.
Datensätze anzeigen .............170
13.2.3.
Datensätze hinzufügen...........171
13.2.4.
Datensätze suchen ................172
13.2.5.
Datensätze ändern.................174
13.2.6.
Datensätze löschen................177
Ausblick in die indizierte
Dateiverarbeitung .................................181
14. Das Prinzip der strukturierten
Programmierung ....................................184
15. Ausblick in die objektorientierte
Programmierung ....................................188
Stichwortverzeichnis.....................................198
3. Grundlagen der Programmierung unter Turbo Pascal
Programmaufbau
sprachelemente
datentypen
Variablen und konstanten
prozeduren und funktionen
anweisungen
wertzuweisung
fehlersuche
syntaX
Hilfefunktion
3.
Grundlagen
Pascal
der
3.1.
Der Programmaufbau
Programmierung
von
Turbo
Der einfachste Programmaufbau
Jedes Turbo Pascal-Programm besteht aus verschiedenen Programmteilen, die teilweise in einer vorgegebenen
Reihenfolge und nach bestimmten Regeln anzuordnen sind. Diese Regeln werden in einer Programmiersprache
als Syntax bezeichnet. Wird die Syntax nicht eingehalten, ist das Programm fehlerhaft und der Compiler kann es
nicht verarbeiten.
In seiner einfachsten Form besteht das Turbo Pascal-Programm aus einem Programmkopf und einem Anweisungsteil.
Programmkopf
PROGRAM Hallo;
BEGIN
Anweisungsteil
WriteLn ('Hallo, das ist mein erstes Programm!');
END.
Abbildung 3.1
Der einfachste Programmaufbau
3 - Grundlagen der Programmierung unter Turbo Pascal
33
Übersicht der vollständigen Programmstruktur
Programmkopf
Funktionsbibliotheken (Units)
Konstantendeklaration
Variablendeklaration
Funktionsdefinition
PROGRAM Programmname;
USES Unitname ;
1
CONST Konstantenname1; Konstantenname2
; ...
VAR Variablenname1; Variablenname2; ...
FUNCTION Funktion1;
...
2
FUNCTION Funktion2;
...
Prozedurdefinition
PROCEDURE Prozedur1;
...
3
PROCEDURE Prozedur2;
...
BEGIN
Anweisung1;
4
Anweisungsteil
Anweisung2;
...
END.
Abbildung 3.2
Die gesamte Programmstruktur
Die Programmteile
Notizen
und werden auch als Hauptprogramm bezeichnet.
34
Überblick der Elemente eines Turbo Pascal-Programms
Programmkopf
Der Programmkopf besteht aus der ersten Zeile und beginnt mit dem Schlüsselwort PROGRAM. Schlüsselwörter
sind feststehende Begriffe einer Programmiersprache. In Turbo Pascal ist es unerheblich, ob sie in Klein- oder
in Großbuchstaben geschrieben werden. Hinter dem Schlüsselwort PROGRAM folgt nach einer Leerstelle der
Name des Programms.
Der Programmname kann auch Ziffern enthalten. Er muß jedoch mit einem Buchstaben beginnen. Er darf länger sein als der Name der Programmdatei, muß aber aus einem zusammenhängenden Ausdruck bestehen. Wenn
Sie dem Programmnamen einen Ausdruck aus mehreren Wörtern geben möchten, müssen Sie diese anstatt
durch Leerschritte mit dem Unterstrich _ trennen.
B
eispiel:
PROGRAM Hallo
PROGRAM Programm_13
PROGRAM Guten_Tag
PROGRAM Berechnung_der_km_h
Funktionsbibliotheken (Units)
Eine Unit ist eine Sammlung von vordefinierten Programmelementen (Prozeduren, Funktionen, Variablen,
Konstanten und Datentypen), die nach bestimmten Aufgabengebieten in Bibliotheken gruppiert sind. Auf Units
können Sie jederzeit zugreifen. Sie können die mitgelieferten Units von Turbo Pascal verwenden und eigene
Units erstellen. Weitere Beschreibungen über Units finden Sie in Kapitel 8.
Das Schlüsselwort USES weist den Compiler an, die hinter diesem Wort aufgeführte Unit in Ihr Programm einzubinden. Wenn Sie Funktionen verwenden wollen, die in Units verwaltet werden, müssen Sie für die USESAnweisung den Namen der Unit wissen.
B
eispiel:
Um den Bildschirm zu löschen, bevor der Programmablauf beginnt, brauchen Sie die Funktion ClrScr (Abkürzung für: Clear Screen). Diese Funktion ist in einer Standard-Unit mit
dem Namen Crt abgelegt. Wenn Sie die Funktion benutzen wollen, müssen Sie folgende
Angaben vor dem Anweisungsteil vornehmen:
USES Crt;
Crt enthält Funktionen für die Ausgabe und Eingabe am Bildschirm. Dos enthält Funktionen
für die Arbeit mit Dateien. String enthält Funktionen für die Arbeit mit Zeichenketten.
Konstanten sind Größen, deren Werte (Zahlen, Zeichen, Zeichenketten ...) sich während des Programmablaufs
nicht ändern können. Der Teil eines Programms, in dem Variablen oder Konstanten definiert werden, heißt
Deklarationsteil oder Vereinbarungsteil. Sie haben die Möglichkeit, Konstanten im Konstantendeklarationsteil
nach dem Schlüsselwort CONST zu benennen und ihnen einen Wert zuzuweisen. Näheres zu den verschiedenen
Konstantentypen finden Sie in späteren Abschnitten.
B
eispiel:
CONST
Mehrwertsteuer = 0,15;
TageProJahr = 360;
Begruessung = 'Guten Morgen';
Den Konstanten Mehrwertsteuer, TageProJahr und Begruessung werden jeweils feste
Werte zugewiesen, die sich während des Progammlaufs nicht ändern.
Variablen sind Größen, die während des Programmlaufs unterschiedliche Werte annehmen können. Die Variablendeklaration beginnt nach dem Schlüsselwort VAR. Eine ausführliche Beschreibung der Variablendeklaration
finden Sie in Abschnitt 3.2.
B
eispiel:
VAR
35
Ergebnis: Integer;
Wohnort: String;
Die Variable Ergebnis erhält den Datentyp der ganzen Zahlen (Integer), d.h. der Variablen Ergebnis können ganzzahlige Werte zugewiesen werden. Die Variable Wohnort ist ein
String-Datentyp; ihr können bis zu 255 Zeichen zugewiesen werden. Eine ausführliche Beschreibung über Datentypen finden Sie in den nächsten Abschnitten.
Funktionsdefinitionen
Wenn ein Programm sehr umfangreich ist oder Programmteile sich oft wiederholen, lohnt es sich, ein Programm in handliche Teile (Funktionen oder Prozeduren) zu zerlegen. Funktionen sind Programmteile, die beispielsweise für das Hauptprogramm eine Berechnung durchführen und das Ergebnis dem Hauptprogramm zurückliefern. Die Bedeutung von Funktionen wird in Abschnitt 6.1 ausführlich beschrieben.
B
eispiel:
Sie haben ein Programm, das Ihren durchschnittlichen Benzinverbrauch berechnet. Dann
können Sie eine Funktion VerbrauchBerechnen() schreiben, die die Berechnung durchführt. Im Anweisungsteil Ihres Programms rufen Sie die Funktion VerbrauchBerechnen()
auf. Diese berechnet den durchschnittlichen Benzinverbrauch und gibt das Ergebnis an das
Hauptprogramm zurück.
Prozedurdefinitionen
Prozeduren sind ebenfalls Programmteile. Beispielsweise sind WriteLn() und ReadLn() Standard-Prozeduren
von Turbo Pascal. Der Unterschied zwischen Prozeduren und Funktionen besteht darin, daß Funktionen ein Ergebnis für das Programm berechnen und an das Programm zurückgeben. Eine Prozedur liefert dem Programm
kein Ergebnis. Sie enthält Anweisungen, die vom Hauptprogramm ausgegliedert sind und nacheinander abgearbeitet werden, sobald sie aufgerufen wird. Die Unterschiede werden in Abschnitt 6.1 verdeutlicht.
B
eispiel:
Sie schreiben ein Programm, das Rechnungen ausgibt. Damit Sie nicht für jede Rechnung
Anweisungen wiederholt schreiben müssen, die Ihre Adresse ausgeben, können Sie einmal
eine Prozedur schreiben, die Ihre Adresse im Rechnungskopf ausgibt. Im Anweisungsteil Ihres Programms brauchen Sie nicht bei jeder Rechnung die Adresse neu einzugeben sondern
nur die Prozedur Adresse() aufzurufen.
Anweisungsteil
Der Anweisungsteil beginnt mit dem Schlüsselwort BEGIN und endet mit dem Wort END. Dazwischen liegen
alle Arbeitsschritte, die das Programm ausführen soll. Die einzelnen Arbeitsschritte werden von oben nach unten abgearbeitet. Mit Hilfe von Steueranweisungen (Kontrollkonstrukten) kann diese Arbeitsreihenfolge auch
verändert werden (siehe Kapitel 4).
Wichtig: Jede Anweisung wird mit einem Semikolon (;) abgeschlossen.
BEGIN und END sind keine Anweisungen. Deshalb steht hinter BEGIN kein Semikolon. Der Anweisungsteil wird
mit dem Schlüsselwort END gefolgt von einem Punkt (.) abgeschlossen.
B
eispiel:
BEGIN
WriteLn ('Hallo, das ist mein erstes Programm.');
WriteLn ('Das Programm demonstriert eine Ausgabe am Bildschirm.');
END.
Notizen
36
3.2.
Variablen
Variablen werden im Deklarationsteil mit einem Namen und einem Datentyp vereinbart. Die Reihenfolge der
Vereinbarungen können Sie selbst festlegen. Jede Variable, die Sie im Anweisungsteil benutzen, muß zuvor definiert werden.
Für jede Variable wird ein Speicherplatz im Arbeitsspeicher Ihres Computers reserviert. Der Anweisungsteil des
Programms kann diese Variablen mit Hilfe der Variablennamen ansprechen und ihnen Werte zuweisen.
im Arbeitsspeicher
Wertzuweisung
im Arbeitsspeicher
-------------------------
--------10
-----------------
Ausgabe
am Bildschirm
10
Die Variable
Menge hat jetzt
den Wert 10
Platzhalter der
Variablen Menge
VAR Menge: Integer;
Menge := 10;
WriteLn (Menge);
Syntax der Variablendeklaration
þ
þ
þ
þ
þ
þ
þ
Die Variablenvereinbarung wird mit dem
VAR Variablenname1: Datentyp;
Schlüsselwort VAR eingeleitet.
Variablenname2: Datentyp;
Das Schlüsselwort VAR muß nur einmal
angegeben werden.
Variablenname3, Variablenname4: Datentyp;
Anschließend folgen die Namen der Va...;
riablen.
Alle Namen eines Deklarationsteils müssen einmalig sein, damit ein eindeutiger Zugriff auf den Variableninhalt gegeben ist.
Hinter dem Variablennamen und einem Doppelpunkt wird der Datentyp angegeben, damit der Computer
weiß, wieviel Speicherplatz er für die Variable reservieren muß.
Variablen, die denselben Datentyp haben, können, durch Kommata getrennt, aufgelistet werden. Abschnitt
3.4 beschreibt wichtige Standard-Datentypen.
Jede Zeile, die mit der Datentyp-Angabe endet, wird mit einem Semikolon abgeschlossen.
B
eispiel:
ý
ý
VAR
Menge, Preis, Betrag : Real;
VAR
Alter : Byte;
PostLZahl : LongInteger;
Geschlecht : Char;
Gültigkeitsbereich von Variablen
Globale Variablen
Variablen, die im Hauptprogramm definiert werden, können im Hauptprogramm sowie
in Prozeduren und Funktionen angesprochen werden. Sie müssen nur einmal deklariert
werden und haben somit globale Gültigkeit.
Lokale Variablen
Variablen, die innerhalb von Prozeduren und Funktionen vereinbart werden, sind nur für
die jeweilige Prozedur oder Funktion gültig. Sie sind anderen Prozeduren und Funktionen sowie dem Anweisungsteil des Hauptprogramms nicht bekannt.
37
Die Verwendung von Variablen im Programm
B

eispiel:
Das Programm berechnet zwei verschiedene Beträge mit den Variablen Menge und Preis.
PROGRAM Rechnungsbetrag1_ausgeben;
USES
Crt;
VAR
Menge, Preis, Betrag : Integer;
BEGIN
ClrScr;
Menge := 10;
Preis := 22;
Betrag := Menge * Preis;
WriteLn (Betrag);
Menge := 13;
Preis := 8;
WriteLn (Betrag);
END.
Abbildung 3.3
Quellprogramm BETRAG1.PAS
Abbildung 3.4
Das Programm BETRAG1
Die Numerierung am rechten Rand der Beispiel-Quellprogramme ist nicht Bestandteil der Programme. Sie dient lediglich der Programmerläuterung.

In diesem Programm wird das erste Mal eine Prozedur (ClrScr bei ) aufgerufen, die in einer Funktionsbibliothek (Unit) verwaltet wird. Damit Sie diese Prozedur in Ihrem Programm verwenden können,
muß vor dem Anweisungsteil die Unit definiert worden sein, die diese Prozedur enthält. Das Schlüsselwort
USES leitet die Einbindung der Unit ein. Danach folgt die Bezeichnung der Unit. Die Prozedur ClrScr ist
in der Unit Crt abgelegt, die Prozeduren und Funktionen für die Bildschirmein- und -ausgabe enthält.
Die Variablen Menge, Preis und Betrag werden hier nach dem Schlüsselwort VAR deklariert. Sie sind alle
drei vom Datentyp der ganzen Zahlen (Integer).
Die Prozedur ClrScr (Abkürzung für: Clear Screen) hat die Aufgabe, den Bildschirm zu löschen. Sie ist
in der Standard-Unit Crt abgelegt, die vor dem Anweisungsteil bei
eingebunden sein muß, damit der
Compiler den Prozeduraufruf ClrScr erkennt.
Der Zuweisungsoperator := weist den Variablen Menge und Preis absolute Werte zu, d.h. die beiden Variablen Menge und Preis, die bis jetzt lediglich einen Platzhalter darstellten und noch keine Werte besaßen, bekommen nun die Werte 10 bzw. 22 zugewiesen. Die Variable, die das Ergebnis zugewiesen bekommt, steht immer auf der linken Seite des Zuweisungsoperators. Auf der rechten Seite steht der Wert als
absoluter Wert (beispielsweise 10, 130, 'Hallo') oder als Variable, die ihren Inhalt auf die andere Variable
überträgt.
Notizen

38
Die allgemeine Syntax für diese Wertzuweisung lautet:
Variable1 := Wert
Variable2 := Variable3
absoluter Wert
neuer Inhalt

neuer Inhalt
Variable2
Inhalt von
Variable3
Diese Anweisungen weichen von der gewohnten Reihenfolge einer Rechenoperationen (Menge * Preis =
Betrag) ab, da die Ergebnisvariable auf der linken Seite steht. Sie können diese Anweisung wie folgt lesen:
Der Wert der Variablen Betrag ergibt sich aus dem Wert der Variablen Menge multipliziert mit dem Wert
der Variablen Preis. Die Variable, der das Ergebnis zugewiesen wird, steht immer auf der linken Seite
des Zuweisungsoperators. Die Berechnung bzw. der Ausdruck, der angibt, wie ein Wert gebildet wird,
steht auf der rechten Seite. Allgemein lautet die Syntax einer Wertzuweisung für eine Berechnung:
Ergebnisvariable := Rechenoperation

B

Die Prozedur WriteLn() bewirkt, daß der Wert der Variablen Betrag am Bildschirm angezeigt wird und
der Cursor danach in die nächste Zeile springt. Hinter dem Schlüsselwort WriteLn wird in runden Klammern die Variable gesetzt, deren Inhalt am Bildschirm erscheinen soll.
Die Variablen ändern ihre Werte durch Wertzuweisungen. Hier wird deutlich, daß eine Variable unterschiedliche Werte annehmen kann. Die Variablen behalten ihre Werte so lange, bis ihnen ein neuer Wert
zugewiesen wird. Die Variable Menge hat am Anfang noch keinen Wert (lediglich der Datentyp wurde
festgelegt), dann den Wert 10 und danach 13.
eispiel:
Das Programm berechnet den Betrag aus den Variablen Menge und Preis, nachdem die Werte
über die Tastatur eingegeben wurden.
USES
Crt;
VAR
Menge, Preis, Betrag : Integer;
BEGIN
ClrScr;
WriteLn ('Bitte geben Sie die Menge ein: ');
ReadLn (Menge);
WriteLn ('Bitte geben Sie den Preis ein: ');
ReadLn (Preis);
WriteLn ('Ihre Rechnung beträgt: ');
WriteLn (Betrag);
END.
Abbildung 3.5
Abbildung 3.6
Das Programm BETRAG2

ReadLn()fordert Sie zu einer Eingabe über die Tastatur auf und setzt den Cursor an den Anfang der
nächsten Zeile. Das Programm wird angehalten und wartet auf einen Eingabewert von der Tastatur, den Sie mit
RETURNTASTE
bestätigen müssen. Danach wird das Programm fortgesetzt. Hinter dem Schlüsselwort ReadLn
werden in runden Klammern die Variable oder die Variablen gesetzt, die ihre Werte vom Anwender über die Tastatur erhalten sollen.
Übung
⇒
Schreiben Sie ein Programm ADRESSE1, das Ihre Adresse am Bildschirm abfragt und anschließend am
Bildschirm ausgibt. Verwenden Sie dafür die Variablen Name, Vorname, Strasse, Plz und Ort, die den
Datentyp String (Zeichenketten) besitzen.
⇒
39
Schreiben Sie ein Programm FLAECHE1, das die Fläche eines Raumes berechnen kann. Verwenden Sie
dabei die Variablen Laenge, Breite und FlaecheInQm. Die Längen- und Breitenangaben sollen von der
Tastatur eingelesen und die Fläche in qm ausgegeben werden.
3.3. Konstanten
Konstanten werden im Konstantendeklarationsteil vereinbart. Die Reihenfolge der Vereinbarungen können Sie
selbst festlegen. Alle Konstanten, die Sie benutzen wollen, müssen ebenfalls wie Variablen vor dem Anweisungsteil definiert werden. Ein konstanter Wert erhält im Deklarationsteil einen Namen, der im Programm an Stelle des
Wertes verwendet werden kann.
Die Verwendung von Konstanten hat den Vorteil, daß eine Änderung eines Wertes nur im Deklarationsteil vorgenommen werden muß und nicht jedesmal, wenn der Wert innerhalb des Anweisungsteils auftritt. Beispielsweise kann der Wert Mehrwertsteuer als Konstante im Deklarationsteil mit 0.15 (= 15 %) festgelegt werden. Im Anweisungsteil wird statt des Wertes nur mit der Konstantenbezeichnung beispielsweise MwSt gerechnet. Falls sich
dieser Wert ändert, brauchen Sie ihn nur einmal im Deklarationsteil zu ändern.
Untypisierte Konstanten
Der Wert einer untypisierten Konstanten läßt sich während des Programmlaufs nicht ändern. Wenn Sie im Anweisungsteil einer untypisierten Konstanten einen anderen Wert zuweisen wollen, bricht der Compiler während
des Compiliervorgangs ab und gibt Ihnen eine Fehlermeldung aus, beispielsweise: FEHLER 113: SYNTAXFEHLER
IN BEFEHL/ANWEISUNG.
im Arbeitsspeicher
Wertzuweisung
im Arbeitsspeicher
--------0.15
-----------------
--------0.15
-----------------
Ausgabe
am Bildschirm
0.15
Anfangswert der
untypisierten
Konstanten MWSt
CONST MWSt = 0.15;
Notizen
MwSt := 0.13;
NICHT MÖGLICH!
WriteLn (MWSt);
40
Syntax der untypisierten Konstanten
þ
þ
þ
þ
þ
þ
Die Konstantenvereinbarung wird mit dem Schlüsselwort
CONST eingeleitet.
Das Schlüsselwort CONST muß nur einmal angegeben werden.
Anschließend folgen die Namen der Konstanten.
Alle Namen müssen einmalig sein, um einen eindeutigen
Zugriff auf den Inhalt zu bekommen.
Die Wertzuweisung erfolgt durch das Gleichheitszeichen =.
In jeder Zeile steht nach der Wertzuweisung ein Semikolon.
B
eispiel:
CONST
CONST Konstantenname1 = Wert;
Konstantenname2 = Wert;
Konstantenname3 = Wert;
...;
Grussformel = 'Mit freundlichen Grüßen';
Zinsfaktor = 1.04;
MehrwertSteuer = 0.15;
Typisierte Konstanten
Der Wert einer typisierten Konstanten ist jedoch während des Programmlaufs änderbar. Im Grunde sind typisierte
Konstanten nichts anderes als Variablen, die bereits bei der Deklaration einen Anfangswert erhalten.
im Arbeitsspeicher
--------999
-----------------
Wertzuweisung
im Arbeitsspeicher
--------500
-----------------
Anfangswert der
typisierten Konstanten
MaxZahl
CONST MaxZahl: Integer = 999;
Ausgabe
am Bildschirm
500
Die typisierte Konstante
Maxzahl
hat jetzt den Wert 500
MaxZahl := 500;
WriteLn (MaxZahl);
Syntax der typisierten Konstanten
þ
þ
Es gelten die gleichen Regeln wie bei untypiCONST Konstantenname1 : Datentyp = Wert;
sierten Konstanten.
Konstantenname2 : Datentyp = Wert;
Zusätzlich wird vor jeder Wertzuweisung nach
einem Doppelpunkt der Datentyp der KonKonstantenname3 : Datentyp = Wert;
stanten festgelegt. Diese Datentyp-Angabe
...;
zeigt damit, daß der Inhalt der Konstanten variabel ist.
Jede Zeile wird nach der Wertzuweisung durch ein Semikolon abgeschlossen.
þ
B
eispiel:
CONST
MaxZahl : Integer = 9999;
MinZahl : Integer = 1;
Monat : String = 'Januar';
Typisierte Konstanten können jedoch zu Mißverständnissen mit Variablen führen, da ihre Inhalte
nicht konstant, sondern variabel sind. Aus Gründen der Genauigkeit und Klarheit, sollten Sie Ihre
Werte nur als Konstanten deklarieren, wenn Sie sicher sind, daß sie sich im Laufe des Programms
nicht ändern. Wenn Sie die Variablen mit Anfangswerten belegen müssen, dann können Sie das
auch im Anweisungsteil durch eine Wertzuweisung realisieren.
41
Die Verwendung von Konstanten im Programm

USES
Crt;
CONST
Frage1 = 'Bitte geben Sie die Menge ein: ';
Frage2 = 'Bitte geben Sie den Betrag ein: ';
Ergebnis = 'Ihre Rechnung beträgt in DM ';
VAR
Menge, Preis, Betrag: Integer;
BEGIN
ClrScr;
WriteLn (Frage1);
ReadLn (Menge);
WriteLn (Frage2);
ReadLn (Preis);
WriteLn (Ergebnis, Betrag);
END.
Abbildung 3.7

Hier beginnt die Konstantendeklaration, die mit dem Schlüsselwort CONST eingeleitet wird. Die Konstanten Frage1, Frage2 und Ergebnis sind untypisierte Konstanten, die alle eine Zeichenkette als festen
Wert erhalten. Im Gegensatz zum vorherigen Beispiel sind diese Zeichenketten aus dem Anweisungsteil
herausgenommen und als untypisierte Konstanten festgesetzt worden.
Das Programm verwendet nur noch die Konstantennamen, um den Inhalt (die beiden Fragen und das Ergebnis) am Bildschirm auszugeben. Die Funktion WriteLn() erlaubt es, mehrere Variablen, Konstanten
oder beides am Bildschirm auszugeben. Die genaue Beschreibung dieser Funktion finden Sie in Abschnitt 3.6.

USES
Crt;
CONST
Menge = 10;
Preis = 50;
Ergebnis = 'Rechnungsbetrag in DM ';
VAR
Betrag : Integer;
BEGIN
ClrScr;
WriteLn (Ergebnis, Betrag);
END.
Abbildung 3.8
Notizen
42
Die Konstanten Menge und Preis und Ergebnis sind hier als untypisierte Konstanten festgelegt. Die

Konstanten Menge und Preis besitzen ganzzahlige Werte (Datentyp Integer), die Konstante Ergebnis
ist vom Datentyp String (Zeichen und Zeichenketten).
Hier wird eine Berechnung mit den Konstanten Menge und Preis durchgeführt. Das Ergebnis wird der
Variablen Betrag zugeordnet. Die Berechnung erfolgt mit den Werten, die im Konstantendeklarationsteil
vordefiniert wurden. Diese Anweisung stellt wieder eine Wertzuweisung dar. Sie können diese Anweisung
wie folgt lesen: Der Wert der Variablen Betrag ergibt sich aus dem Wert der Konstanten Menge multipliziert mit dem Wert der Konstanten Preis.
Die Funktion WriteLn() bewirkt, daß der Inhalt einer Konstanten und einer Variablen am Bildschirm erscheint.
Gültigkeitsbereich von Konstanten
Globale Konstanten Konstanten, die im Hauptprogramm definiert werden, können im Hauptprogramm sowie
in Prozeduren und Funktionen angesprochen werden. Sie müssen nur einmal deklariert
werden und haben somit globale Gültigkeit.
Lokale Konstanten
Konstanten, die innerhalb von Prozeduren und Funktionen vereinbart werden, sind nur
für die jeweilige Prozedur oder Funktion gültig. Sie sind anderen Prozeduren und Funktionen sowie dem Anweisungsteil des Hauptprogramms nicht bekannt.
Übung
⇒
Schreiben Sie ein Programm ADRESSE2, das Ihre Adresse am Bildschirm ausgibt. Verwenden Sie hierfür
die Konstanten Name, Vorname, Strasse, Plz, Ort.
⇒
Eine Pizzeria möchte zusätzlich zum Pizza-Angebot für jede Pizza eine Riesenpizza anbieten, an der 7
Personen essen können. Das Programm PIZZA1 berechnet den Preis einer Riesenpizza für verschiedene
Pizzasorten. Der Preis wird aus dem Preis einer kleinen Pizza berechnet und einem Nachlaß von DM 10,--.
Überlegen Sie sich, bevor Sie das Programm schreiben, welche Konstanten und Variablen im Programm
eingesetzt werden können.
3.4. Einführung wichtiger Standard-Datentypen
Der Datentyp einer Variablen oder Konstanten legt den Wertebereich und somit die Größe des Speicherplatzes in der Größenordnung Byte im Computer fest (vgl. auch Abschnitt 1.1.). Im Deklarationsteil Ihres Programms müssen Sie deshalb den Variablen und
Konstanten Datentypen zuordnen.
Numerische Datentypen
Adresse : String[60]
Farbe : Char
Preis : Real
Menge : Integer
Abbildung 3.9
Speicherreservierung
Arbeitsspeicher
im
Die folgende Tabelle zeigt zwei wichtige numerische Datentypen. Weiter numerische Datentypen sind im Abschnitt 9.1 ausführlich beschrieben.
43
Typ
Wertebereich
Beispiele
Real
Alle positiven und negativen reellen Zahlen, auch Dezi- 20.5 oder - 682.43
malzahlen
(Turbo Pascal kennt für Dezimalzahlen die amerikanische
Schreibweise: siehe nachfolgenden Hinweis)
Ganzzahlige Werte
Integer
455 oder - 2036
Beachten Sie, daß Turbo Pascal für Werte vom Datentyp Real die amerikanische Schreibweise
verwendet. Sie müssen also auch bei der Eingabe über die Tastatur auf diese Schreibweise achten:
z.B. deutsche Schreibweise:
4.350.299,40
amerikanische Schreibweise:
4,350,299.40
Operationen mit numerischen Daten
ý
Addition:
ý
Ergebnis
78
:=
:=
Zahl1 + Zahl2
50 + 28
Subtraktion:
ý
Ergebnis
40
:=
:=
Zahl1 - Zahl2
55 - 15
Multiplikation:
ý
Ergebnis
720
:=
:=
Zahl1 * Zahl2
80 *
9
Real-Division:
Ergebnis
5.0000000000E+00
:=
:=
Zahl1 / Zahl2
55.0 / 11.0
Sie können nur zwei numerische Werte mit dem /-Operator dividieren, die vom Datentyp Real sind. Das Ergebnis dieser Berechnung wird in einer Gleitkommaschreibweise ausgegeben. Diese Darstellung ist jedoch unübersichtlich. Deshalb haben Sie die Möglichkeit, diesen Wert in ein Ausgabeformat (vgl. Abschnitt 3.6) zu setzen.
Für numerische Werte vom Datentyp Integer gibt es einen anderen Divisionsoperator:
ý
Integer-Division:
Ergebnis
12
:=
:=
Zahl1 Div Zahl2
126 Div 10
Hier wird 126 durch 10 dividiert. Das Ergebnis wäre 12,6. Bei einer Division von Integer-Werten werden die
Nachkommastellen abgeschnitten. Das Ergebnis zeigt nur die beiden Stellen vor dem Komma.
ý
Divisionsrest:
Ergebnis
6
:=
:=
Zahl1 Mod Zahl2
126 Mod 10
Der mod-Operator berechnet den Divisionsrest der Zahl. Der Divisionsrest von 126 dividiert durch 10 ergibt 6.
Der Divisionsrest sind bei Integer-Werten die eigentlichen Nachkommastellen. Der Mod-Operator gilt ebenfalls
nur für Integer-Werte.
Bei Rechenoperationen gelten die üblichen mathematischen Regeln:
þ
þ
Punktrechnung geht vor Strichrechnung.
Die Reihenfolge der Berechnung kann durch Klammern verändert werden, beispielsweise
Ergebnis := 7 * 10 - 5
Die Variable Ergebnis enthält den Wert 65
Ergebnis := 7 * (10 - 5) Die Variable Ergebnis besitzt hier den Wert 35
Notizen
44
Zeichen und Zeichenketten
Typ
Wertebereich
Char
Char(acter) umfaßt ein Zeichen.
String
Beispiele
Numerische Zeichen: 0 1 2 3 4 5 ...
Alphabetische Zeichen: a b c ... A B C ...
Sonderzeichen: ! " § $ % & * + ...
Ein String ist eine Folge von Zeichen mit unter- Hallo, wie geht es Dir?
schiedlicher Länge. Ein String darf nicht größer Bitte zahlen Sie den Rechnungsbetrag.
als 255 Zeichen sein.
0 61 69 / 44 33 89
Für Zeichen und Zeichenketten gelten folgende Regeln:
þ
þ
þ
þ
þ
Zeichen und Zeichenketten werden durch Apostrophe '...' begrenzt, um sie beispielsweise von Variablen
und Konstanten zu unterscheiden.
Innerhalb des Quellprogramms müssen Zeichenketten in einer Zeile stehen. Ist die Zeile zu lang, müssen
aus einer Zeichenkette zwei gemacht werden.
Eine Zeichenkette kann auch leer sein (siehe nachfolgendes Beispiel).
Ein Apostroph innerhalb einer Zeichenkette läßt sich durch zwei aufeinanderfolgende Apostrophe darstellen (siehe nachfolgendes Beispiel).
Sie haben die Möglichkeit, im Variablendeklarationsteil die Längen für Zeichenketten zu vereinbaren.
Diese werden in eckigen Klammern hinter das Wort String gesetzt. Sie können zwischen 1 und 255 Zeichen wählen. Umfaßt eine Zeichenkette mehr als 255 Zeichen, so muß sie auf mehrere String-Variablen
verteilt werden.
Wenn Sie keine Längenangabe bei String-Variablen machen, legt der Computer automatisch eine Länge von 255 Zeichen fest und stellt dementsprechend den höchsten Speicherplatz für diese
Variable zur Verfügung. Beachten Sie, daß dadurch unnötig der Arbeitsspeicher reduziert wird.
B
eispiel:
(1)
Beispiel: Konstantendeklaration
CONST Anrede1 = 'Sehr geehrte Damen und Herren!;
Anrede2 = 'Hallo wie geht''s Dir?'
Grussformel = 'Mit freundlichen Grüßen';
Platzhalter = '';
(2)
Beispiel: Variablendeklaration
VAR
(3)
Name = String[15];
Strasse = String[20];
Ort = String[20];
BriefEnde = String[20];
Beispiel: Wertzuweisung von String-Werten
BEGIN
BriefEnde := Grussformel;
END.
Die Wertzuweisung einer String-Variablen erfolgt ebenfalls durch den Zuweisungsoperator :=. Beide Variablen müssen vom Datentyp String sein. Die Variable
BriefEnde erhält den Inhalt der Variablen Grussformel.
45
Operationen mit Zeichen und Zeichenketten
Zwei Variablen des Datentyps Char oder String können miteinander durch den +-Operator verbunden werden.
Wenn das Ergebnis mehr als 255 Zeichen ergibt, wird es nach dem 255. Zeichen abgeschnitten.
B
eispiel:
ý
ý
ErgebnisString
'Turbo Pascal'
:=
:=
String1 +
'Turbo ' +
String2
'Pascal'
Alle drei Variablen müssen im Deklarationsteil als String-Datentyp definiert werden,
damit diese Verknüpfung stattfinden kann.
ErgebnisString
'TP'
:=
:=
Char1 + Char2
'T' + 'P'
Wenn zwei Variablen verknüpft werden sollen, die vom Datentyp Char sind, dann muß
die Ergebnisvariable vom Typ String sein, da diese mehr als ein Zeichen, also eine
Zeichenkette, enthält.
Beachten Sie, daß ein Leerschritt auch als ein Zeichen gewertet wird, egal ob vom Datentyp Char
oder String.
Wahrheitswerte
Typ
Wertebereich
Boolean
Die Variablen vom Datentyp Boolean wurden nach dem Mathematiker G. Boole benannt und
werden auch als logische Variablen bezeichnet. Sie werden für Lösungen logischer Probleme
und zur Abfrage von Bedingungen eingesetzt (siehe Abschnitt 4.3).
Es gibt deshalb zwei Werte:
ý
ý
Notizen
TRUE (wahr)
FALSE (falsch)
46
B

eispiel:
PROGRAM
USES
CONST
VAR
Falsch_oder_Richtig;
Crt;
Antwort = 16;
Ergebnis: Boolean;
Eingabe: Integer;
BEGIN
ClrScr;
WriteLn ('Wieviel Buchstaben hat das Wort: GEBURTSTAGSTORTE ?');
ReadLn (Eingabe);
Ergebnis := Antwort = Eingabe;
WriteLn (Ergebnis);
END.
Abbildung 3.10

Dieses Beispiel fordert den Anwender auf, die Anzahl der Buchstaben des Wortes Geburtstagstorte über die Tastatur einzugeben. Ist das Ergebnis richtig, erscheint am Bildschirm das Wort
TRUE. Ist die Eingabe falsch, erscheint am Bildschirm das Wort FALSE.
Quellprogramm FALSCH.PAS
Der Konstanten Antwort wird der Wert 16 zugeordnet. Dieser Wert entspricht der Buchstabenanzahl des
Wortes Geburtstagstorte.
Hier wird eine Variable Ergebnis definiert, der während des Programmlaufs einen booleschen Wert (TRUE
oder FALSE) zugeordnet wird.
Die Variable Eingabe ist ein Integer-Datentyp und soll die Tastatureingabe (Anzahl der Buchstaben)
speichern.
Der Benutzer wird zu einer Eingabe aufgefordert.
Diese Anweisung besteht aus zwei Teilen. Zuerst wird ein Vergleich durchgeführt (Antwort = Eingabe).
Das Ergebnis dieses Vergleichs (entweder wahr oder falsch) wird der Variablen Ergebnis zugewiesen. Da
die Variable Ergebnis als boolescher Wert definiert wurde, erhält sie einen der beiden logischen Werte:
TRUE oder FALSE (als Ergebnis dieses Vergleichs).
Syntax
Wertzuweisung
Beispiel

Boolescher Wert := Variableninhalt
Ergebnis
:=
FALSE
:=
Antwort
16
= Tastatureingabe
=
Eingabe
=
15
Der boolesche Wert TRUE oder FALSE wird am Bildschirm ausgegeben.
Die wichtigsten Operationen mit booleschen Datentypen
Boolesche
Bedeutung
Operatoren
NOT
Verneinung der
Verknüpfung
Beispiel
C
:=
TRUE :=
FALSE :=
NOT
NOT
NOT
AND
C
TRUE
FALSE
FALSE
FALSE
A
TRUE
FALSE
TRUE
FALSE
UND-Verknüpfung
:=
:=
:=
:=
:=
A
FALSE
TRUE
AND
AND
AND
AND
AND
B
TRUE
TRUE
FALSE
FALSE
Die Ergebnisvariable C erhält abhängig von den booleschen Werten der
Variablen A und B entweder den Wert TRUE oder FALSE. Nur wenn beide
Variablen A und B den Wert TRUE besitzen, ist das Ergebnis auch wahr
(TRUE).
OR
ODERVerknüpfung
C
TRUE
TRUE
TRUE
FALSE
:=
:=
:=
:=
:=
A
TRUE
TRUE
FALSE
FALSE
47
OR
OR
OR
OR
OR
B
TRUE
FALSE
TRUE
FALSE
Hier muß mindestens eine Variable den Wert TRUE besitzen, damit das
Ergebnis TRUE wird.
XOR
Exklusive ODERVerknüpfung
C
FALSE
TRUE
TRUE
FALSE
:=
:=
:=
:=
:=
A
TRUE
TRUE
FALSE
FALSE
XOR
XOR
XOR
XOR
XOR
B
TRUE
FALSE
TRUE
FALSE
Eine XOR-Verknüpfung bedeutet hier, daß genau eine Variable wahr, die
andere falsch sein muß, damit das Ergebnis den Wert TRUE erhält.
3.5.
Wichtige Sprachelemente
Reservierte Programmierwörter
Reservierte Programmierwörter von Turbo Pascal sind Wörter, deren Schreibweise und Bedeutung fest vorgegeben sind, d.h. sie sind Bestandteile von Turbo Pascal und können nicht neu definiert werden. Sie müssen während
der Programmierung darauf achten, daß Sie keine Bezeichner bzw. Namen für beispielsweise Konstanten, Variablen, Prozeduren oder Funktionen vergeben, die als reserviertes Programmierwort in Turbo Pascal bereits
existieren. Der Compiler würde während des Compiliervorgangs eine entsprechende Fehlermeldung ausgeben.
B
eispiel:
PROGRAM, BEGIN, END, VAR, CONST, USES, AND, OR, IF
Im Anhang finden Sie eine Auflistung aller reservierten Programmierwörter und Standard-Anweisungen.
Eine Unterscheidung zwischen Groß- und Kleinschreibung findet nicht statt. Sie können alle reservierten Wörter beispielsweise auch wie folgt schreiben:
program, begin, End, Var, Const, uses.
In den Beispiel- und Übungsprogrammen sind alle reservierten Programmierwörter in Großbuchstaben geschrieben, damit die Programme übersichtlich und einfach zu lesen sind.
Notizen
48
Benutzerdefinierte Namen (Bezeichner)
Alle Variablen, Konstanten, Funktionen, Prozeduren, Units und Programme müssen benannt werden. Die Bezeichnungen hierfür können Sie frei wählen. Folgende Regeln sind dabei zu beachten:
þ
þ
Ein Bezeichner kann beliebig lang sein. Allerdings beachtet Turbo Pascal nur die ersten 63 Zeichen.
Er muß mit einem Buchstaben oder einem Untersrich_ beginnen und darf kein Leerzeichen enthalten,
damit der Compiler dieses Wort als Bezeichner erkennt. Danach können Ziffern, Buchstaben oder Unterstriche folgen.
Es gibt keinen Unterschied zwischen Groß- und Kleinschreibung.
Die deutschen Umlaute (ä, ö, ü) und das ß sind nicht zulässig.
Reservierte Programmierwörter dürfen nicht als benutzerdefinierte Wörter verwendet werden.
þ
þ
þ
B
eispiel:
Richtig: Rechnungsbetrag2_ausgeben, Ergebnis, GutenTag, antwort, eingabe
Falsch: Rechnungsbetrag2 ausgeben, Guten Tag, 2.Zinsprogramm
Kommentare
Kommentare dienen zur Programmerläuterung. Sie werden vom Compiler ignoriert (überlesen). Damit der
Compiler einen Kommentar erkennt, werden diese in geschweifte Klammern {...} oder in runde Klammern mit
Stern-Symbolen am Anfang und Ende (*...*) gesetzt.
þ
Programmabschnitte lassen sich durch Kommentare optisch hervorheben. Dadurch wird die Lesbarkeit der
Programme erhöht und Sie finden schnell zu den einzelnen Stellen des Programms, wenn Sie Verbesserungen oder Erweiterungen vornehmen müssen.
Komplexe Anweisungen lassen sich einfach kommentieren.
Die Bedeutung von Variablen und Konstanten kann erklärt werden.
Kommentare erleichtern die Programmdokumentation. Die Dokumentation von Programmen ist ein wichtiger Teil der strukturierten Programmierung (vgl. Kapitel 14).
þ
þ
þ
B
eispiel:
In umfangreichen Programmen ist es oft zweckmäßig, die Variablen so kurz wie möglich zu
halten, um Schreibarbeit zu sparen und übersichtliche Programmstrukturen zu bekommen. Das
folgende Beispiel ist das Programmbeispiel BETRAG5. Die Variablen des Programms wurden
gekürzt und Kommentare wurden eingefügt.
{Die Programmdatei heißt BETRAG5.PAS}
USES
Crt;
{Die Unit Crt wird eingefügt}
CONST
ME = 10;
{ME = Menge, PR = Preis}
PR = 50;
Ausg = 'Rechnungsbetrag in DM ';
VAR
BE : Integer;
{BE = Betrag und Ergebnisvariable}
BEGIN
{Bildschirm löschen}
ClrScr;
{Berechnung durchführen}
BE := ME * PR;
{Ergebnis am Bildschirm ausgeben}
WriteLn (Ausg,BE);
END.
Abbildung 3.11
49
Übung
⇒
Schreiben Sie ein Programm GELD1, das die Höhe der Geldrückgabe berechnet und am Bildschirm ausgibt, nachdem ein zuzahlender Betrag und ein übergebener Betrag über die Tastatur eingegeben wurden.
Verwenden Sie die Variablen ZahlBetrag, GebenBetrag und RueckBetrag des Datentyps Integer sowie die Bildschirmausgaben als Konstanten:
'Wie hoch ist der zuzahlende Betrag in DM?'
'Wie hoch ist der übergebene Betrag in DM?'
'Ihr Rückgeld beträgt in DM '
⇒
Schreiben Sie ein Programm DREIECK, das die Fläche in cm² eines Dreiecks berechnet und am Bildschirm ausgibt, nachdem die Angaben in cm für die Grundlinie und für die Höhe über die Tastatur eingegeben worden sind. Die Variablen sollen vom Datentyp Integer sein.
⇒
Wie könnte ein gut kommentiertes Programm LOHN1 aussehen, das eine Lohnabrechnung eines Arbeiters
am Bildschirm ausgibt, nachdem alle notwendigen Angaben über die Tastatur erfaßt wurden?
Verwenden Sie einen konstanten Stundenlohn von DM 19,-- sowie einen Überstundenzuschlag DM 7,-- je
Stunde. Die Abrechnung soll folgende Angaben enthalten: Adresse des Arbeiters, gesamte Stundenanzahl,
davon Überstundenanzahl und auszuzahlender Lohn. Verwenden Sie für die Berechnung Integer-Datentypen. Verwenden Sie zur Darstellung der Lohnabrechnung am Bildschirm Leerzeilen.
⇒
Wie könnte ein Programm RATEN aussehen, das eine Person B zum Raten einer Zahl zwischen 1 und 10
auffordert, die zuvor von einer anderen Person A eingegeben wurde? Wird die richtige Zahl eingegeben,
soll das Programm mit TRUE antworten, andernfalls mit FALSE.
3.6.
Ein- und Ausgabe
AUSGABE
EINGABE
7
Arbeitsspeicher
530
530
Read (Betrag)
Write (Betrag)
Abbildung 3.12
Notizen
Eingabe und Ausgabe von Variablen
50
Die Eingabeanweisung Read() und ReadLn()
Die beiden Anweisungen Read() und ReadLn() sind Standard-Prozeduren von Turbo Pascal, mit der Daten über
die Tastatur in den Arbeitsspeicher eingegeben werden können. Häufig erfolgt diese Eingabeanweisung nach einer Ausgabeanweisung Write() oder WriteLn(), die auch in diesem Abschnitt erklärt werden. Das Programm
wartet bei einer Read()- oder ReadLn()-Anweisung auf eine Eingabe mit der Tastatur. Jede Eingabe muß mit
abgeschlossen werden. Das Betätigen der RETURNTASTE
füllt die Variable mit dem
der RETURNTASTE
eingegebenen Wert. Dann wird der Programmlauf fortgesetzt.
Read (Variable1, Variable2, ... )
Nach dem Schlüsselwort Read folgt in runden Klammern eine Liste aller Variablen, die über die Tastatur mit
Werten gefüllt werden sollen. Diese Variablen müssen vorher im Deklarationsteil definiert werden. Die Variablen können verschiedene Datentypen besitzen.
ReadLn (Variable1, Variable2, ...)
Das Schlüsselwort ReadLn setzt sich zusammen aus Read + Line und bedeutet, daß nach der Eingabe der Cursor
auf den Anfang der nächsten Zeile gesetzt werden soll. Ansonsten sind die beiden Prozeduren Read() und
ReadLn() gleich.
B
eispiel:
ý
ý
ý
ý
Read (Betrag);
Read (Preis, Menge, Artikelbezeichnung);
ReadLn (Preis, Menge);
ReadLn (Name, Vorname, Strasse, Plz, Ort);
Die Ausgabeanweisung Write() und WriteLn()
Die Write()- und WriteLn()-Anweisungen sind ebenfalls Standard-Prozeduren von Turbo Pascal und bewirken, daß Werte von Variablen und Konstanten am Bildschirm ausgegeben werden, die evtl. vorher mit den
Write()- und WriteLn()-Anweisungen gefüllt worden sind.
Write (Variable1, Variable2, ... )
Write (Konstante1, Konstante2, ...)
Write (Variable1, Konstante1, ...)
Nach dem Schlüsselwort Write folgt in runden Klammern eine Liste aller Variablen und Konstanten, die am
Bildschirm ausgegeben werden sollen. Diese müssen wiederum im Deklarationsteil vordefiniert worden sein.
WriteLn (Variable1, Variable2, ... )
WriteLn (Konstante1, Konstante2, ...)
WriteLn (Variable1, Konstante1, ...)
Das Schlüsselwort WriteLn setzt sich zusammen aus Write + Line und bedeutet, daß nach der Ausgabe der
Cursor auf den Anfang der nächsten Zeile gesetzt werden soll. Ansonsten sind die beiden Prozeduren Write()
und WriteLn() gleich.
B
eispiel:
ý
ý
ý
ý
Write (Betrag, Mwstsatz)
Write (Menge, Preis)
WriteLn (Zinssatz, Kapital)
WriteLn (Zinssatz)
51
Zur Syntax der Prozeduren Read(), ReadLn(), Write() und WriteLn()
þ
þ
þ
Sie können mehrere Variablen und Konstanten mit einer dieser Prozeduren eingeben oder ausgeben.
Die Variablen und Konstanten werden innerhalb der runden Klammern mit Kommata getrennt.
Das Ausgabeformat einer Variablen oder Konstanten folgt direkt nach einem Doppelpunkt hinter der Variablen oder Konstanten. Zuerst wird die Anzahl der Stellen insgesamt angegeben. Nach einem weiteren
Doppelpunkt wird (je nach Datentyp) die Anzahl der Nachkommastellen aufgeführt.
Unterschied bei der Verwendung von Read() und ReadLn()
Wenn Sie eine Tastatureingabe mit Read() oder ReadLn() vornehmen, wird die Eingabe in einen Puffer geabgeschlossen. Danach speichert Turbo Pascal den eingegebenen Inhalt
schrieben und mit der RETURNTASTE
in den Datenspeicher der Variable.
ý
ý
ReadLn() überträgt den eingegebenen Inhalt aus dem Puffer in die Variable und entfernt das Zeichen für
aus dem Puffer.
Read() überträgt den eingegebenen Inhalt aus dem Puffer in die Variable und entfernt das Zeichen für die
RETURNTASTE
aus dem Puffer nicht.
die
RETURNTASTE
PUFFER
Eingabe mit readLn
ReadLn (4712)
4712
Eingabe mit read
4712
Abbildung 3.13
Die
4712
RETURN
PUFFER
Read (4712)
PUFFER
VARIABLE
=
PUFFER
VARIABLE
4712
RETURN
=
RETURN
Unterschied der ReadLn()- zur Read()-Prozedur
wird im Puffer als ein Zeichen gewertet. Wenn Sie beispielsweise eine Variable mit
RETURNTASTE
Read() lesen, die vom Datentyp Char ist, kann es vorkommen, daß der Puffer nicht leer ist, da das Zeichen für
die
RETURNTASTE
noch im Puffer enthalten ist.
Damit ihre Programme einwandfrei laufen können, verwenden Sie daher die ReadLn()-Prozedur.
Der Puffer wird dann nach jeder Übertragung des Inhalts in die Variable wieder geleert.
Die Ausgabeformatierung numerischer Datentypen
Die Prozeduren Write() und WriteLn() bewirken eine Ausgabe der Variablenwerte am Bildschirm, exakt in
der Darstellung, wie sie gespeichert wurden. Manche Darstellungen sind jedoch oft unübersichtlich. Ziel der
Ausgabeformatierung ist es, eine gut lesbare Ausgabe für den Benutzer zu erhalten.
Der Datentyp REAL
Ergebnis :=
Notizen
40.55 + 20.2
Ergebnis ohne Formatierung
Write (Ergebnis)
6.0750000000E+01
Ergebnis mit Formatierung
Write (Ergebnis:7:2)
60.75
52
Die Darstellung von Variablen des Datentyps Real wird am Bildschirm in der unformatierten Form als Gleitkommazahl ausgegeben, was auf den Benutzer sehr unleserlich wirken kann. Es gibt nun die Möglichkeit, der
Write-Anweisung weitere Informationen zu geben, um den Inhalt der Variablen in eine besser lesbare Ausgabeform zu bringen.
Write (RealVariable1 : Anzahl der Stellen insg. : Anzahl der Nachkommastellen, ...)
Write (
Ergebnis
:
7
:
Diese Erweiterung der Write-Anweisung bedeutet
nun, daß die Ausgabe der Variablen Ergebnis insgesamt 7 Stellen besitzt, wobei diese 7 Stellen ein
Vorzeichen, einen Dezimalpunkt und 2 Nachkommastellen beinhalten.
1
2
2
3
4
5
6
6
0 . 7 5
)
7
Nachkommastellen = 2
Dezimalpunkt
Vorkommastellen = 3
Es lassen sich auch Integer-Werte in Ausgabeformate bringen. Dabei fallen die Nachkommastellen weg, beispielsweise Write(Zahl:5).
Vorzeichen (nur bei negativen Zahlen -)
Sie können zu den Variablen- oder Konstantenwerten auch erläuternde Texte ausgeben. Diese Texte sind dann
vom Datentyp String und müssen deshalb in Apostrophe gesetzt werden (siehe nachfolgende Beispiele).
B
eispiel:
ý
Write ('Das Ergebnis lautet: ', Ergebnis:7:2)
Mit dieser Anweisung wird zuerst eine Textkonstante ausgegeben. Danach folgt die
formatierte Ausgabe der Variablen Ergebnis, die 7 Stellen lang ist und 2 Nachkommastellen besitzt.
ý
Write ('-----', Betrag:10:1, '-----')
Die Variable Betrag wird zwischen 2 Textkonstanten ausgegeben. Sie ist in dem Fall
10-stellig und besitzt nur eine Nachkommastelle.
ý
Write ('
', Grußformel);
Hier wird eine leere Zeichenkette ausgegeben, die mehrere Leerstellen enthält. Danach
wird die Variable Grußformel ausgegeben, die ebenfalls als Wert eine Zeichenkette
enthalten kann. Der Wert ist hier jedoch nicht ersichtlich, er läßt sich durch den Variablennamen höchstens vermuten.
ý
Write (Betrag:10:2, Ergebnis:8)
Es werden die zwei formatierten Variablen Betrag und Ergebnis ausgegeben, wobei
die erste Variable 10 Stellen mit 2 Nachkommastellen besitzt und die zweite Variable 8stellig ist ohne Nachkommastelle. Hier kann die Variable Ergebnis auch vom Typ Integer sein.
Die in diesem Abschnitt aufgeführten Erläuterungen und Beispiele für die Eingabe lassen sich
nicht nur mit Read() sondern auch mit ReadLn() durchführen. Das gleiche gilt für die Erläuterungen und Beispiele der Ausgabeprozeduren Write() und WriteLn().
Ein- und Ausgabeformatierung am Bildschirm mit GotoXY()
Wenn viele Werte von der Tastatur eingelesen oder eine große Anzahl von
Texten und Variablen am Bildschirm ausgegeben werden, ist es sinnvoll,
die Ein- und Ausgabe am Bildschirm leserlich aufzubereiten. Hilfreich ist
hierfür die Prozedur GotoXY(), die den Cursor, den Inhalt einer Variablen
oder eine Konstante an eine bestimmte Zeile und Spalte auf den Bildschirm
positioniert. Die Prozedur GotoXY() benötigt deshalb eine Spalten- und
Zeilenangabe auf dem Bildschirm, der in 80 Spalten und 25 Zeilen eingeteilt ist.
GotoXY (Spalte, Zeile)
80 Spalten
25 Zeilen
B

eispiel:
Dieses Programm ADRESSE3 gibt eine Adresse formatiert am Bildschirm aus, die vorher
über die Tastatur ebenfalls formatiert eingegeben wurde.
PROGRAM Adresse_abfragen_und_ausgeben;
USES
Crt;
VAR
Name, Strasse, Ort : String[20];
Plz : String[5];
BEGIN
ClrScr;
{Hier wird zuerst der Eingabebildschirm aufbereitet}
GotoXY (10,5);
WriteLn ('-------------- Adresse eingeben -----------------');
GotoXY (10,6);
WriteLn ('-------------------------------------------------');
GotoXY (10,8);
WriteLn ('Vorname/Name ...... :');
GotoXY (10,10);
WriteLn ('Strasse ........... :');
GotoXY (10,12);
WriteLn ('PLZ:');
GotoXY (23,12);
WriteLn ('Ort .. :');
GotoXY (35,8);
{Hier beginnen die Eingabeanweisungen}
ReadLn (Name);
GotoXY (35,10);
ReadLn (Strasse);
GotoXY (16,12);
ReadLn (Plz);
GotoXY (35,12);
ReadLn (Ort);
ClrScr;
{Hier beginnt die Bildschirmausgabe}
GotoXY (10,5);
WriteLn ('---------------- Adresse ausgeben ---------------');
GotoXY (10,6);
WriteLn ('-------------------------------------------------');
GotoXY (20,8);
WriteLn (Name);
GotoXY (20,10);
WriteLn (Strasse);
GotoXY (20,12);
WriteLn (Plz);
GotoXY (27,12);
WriteLn (Ort);
END.
Abbildung 3.14
Notizen
53
Quellprogramm ADRESSE3.PAS
54

Die Prozedur GotoXY() wird in der Unit Crt verwaltet. Um diese Prozedur in das Programm einzubinden, muß der Eintrag Crt hinter dem Schlüsselwort USES erfolgen.
Die Anweisung GotoXY (10,5) bewirkt, daß das erste Zeichen der nachfolgenden Konstanten-Ausgabe
in Spalte 10 und in Zeile 5 erfolgt.
Hier wird der Cursor für die nachfolgende Eingabe in Spalte 35, Zeile 8 positioniert.
Diese GotoXY()-Anweisung bewirkt, daß die nachfolgende Variable Name in Spalte 20, Zeile 8 ausgegeben wird.
Übung
⇒
Ändern Sie die Variablen des Programms PIZZA1 (vgl. Abschnitt 3.3) vom Datentyp Integer in den
Datentyp Real um, und zentrieren Sie Ein- und Ausgabe am Bildschirm. Speichern Sie das Programm
unter dem Namen PIZZA2.PAS.
⇒
Ändern Sie das Programm LOHN1 (vgl. Abschnitt 3.5) so ab, daß das Programm mit Variablen vom Datentyp Real arbeitet, und bringen Sie die Ein- und Ausgabe in eine übersichtliche Form. Speichern Sie
dieses Programm unter dem Namen LOHN2.PAS.
⇒
Schreiben Sie ein Programm, das diesen Eingangsbildschirm
der Lohnabrechnung zentriert am Bildschirm ausgibt. Legen Sie
alle notwendigen Konstanten im Deklarationsteil fest. Speichern
Sie es unter dem Namen LOHNBILD.PAS.
3.7.
**********************************
**
**
*
*
*
--- Guten Tag --*
*
*
*
Dieses Programm gibt
*
*
eine Lohnabrechnung aus.
*
*
*
**
**
**********************************
Syntaxmarkierung in Turbo Pascal
Sprachelemente farbig markieren
Wenn Sie Ihr Programm schreiben, sehen Sie, daß
Turbo Pascal verschiedene Wörter oder Anweisungen andersfarbig darstellt. Beispielsweise sind
standardmäßig benutzerdefinierte Wörter weiß und
die restlichen Sprachelemente gelb. Die unterschiedliche Markierung soll Ihnen das Auffinden
von Programmteilen erleichtern. Die Programmstruktur wird übersichtlich, und Sie erkennen oft
bei nicht einwandfreien Compiliervorgängen
Abbildung 3.15
schneller Ihre Fehler.
Aktuelle Farbe
Das Dialogfenster FARBEN
Wenn Sie auch andere Sprachelemente farblich hervorheben wollen, müssen Sie folgende Veränderungen vornehmen:
⇒
Rufen Sie den Menüpunkt OPTION - UMGEBUNG - FARBEN auf.
⇒
Wählen Sie im Listenfeld GRUPPE den Eintrag SYNTAX. Im Listenfeld ELEMENT werden alle Sprachelemente von Turbo Pascal sichtbar.
⇒
Klicken Sie mit der linken Maustaste auf das Element, das Sie farblich verändern wollen. Ein Kreis in den
beiden Farbpaletten VORDERGRUND und HINTERGRUND zeigt Ihnen die aktuelle Farbeinstellung zu dem
gewählten Element.
⇒
Um die Farbeinstellungen zu ändern, klicken Sie mit der linken Maustaste auf die gewünschte Farbe der
VORDERGRUND-Farbpalette und HINTERGRUND-Farbpalette.
Unterhalb der beiden Farbpaletten zeigt Ihnen Turbo Pascal, wie die gewählte Farbeinstellung wirkt.
⇒
Bestätigen Sie mit OK oder mit der
RETURNTASTE
.
55
Syntaxmarkierung ausschalten
⇒
Rufen Sie den Menüpunkt OPTION - UMGEBUNG - EDITOR auf.
⇒
Schalten Sie das Kontrollfeld TEXTFARBEN
aus.
⇒
Bestätigen Sie mit OK, oder betätigen Sie
.
die RETURNTASTE
Alle Sprachelemente Ihres Quellprogramms
besitzen nun eine einheitliche Farbe.
Abbildung 3.16
Das Dialogfenster EDITOR-EINSTELLUNGEN
Sprachelemente markiert drucken
Sie haben die Möglichkeit, die farblich markierten Sprachelemente beim Drucken hervorzuheben. Dazu muß Ihr
Quellprogramm vor dem Drucken durch das Filterprogramm PRNFLTR.EXE laufen. Diese Einstellung ist standardmäßig vorgenommen. Falls Ihre Quellprogramme nicht mit unterschiedlichen Markierungen gedruckt werden, müssen Sie folgende einmalige Einstellung vornehmen:
⇒
Wählen Sie den Menüpunkt DATEI DRUCKERINSTALLATION.
⇒
Schreiben Sie in das Eingabefeld PFAD FÜR
FILTER den Programmnamen PRNFLTR.
⇒
Aktivieren Sie das Kontrollfeld SYNTAXHERVORHEBUNG.
⇒
Bestätigen Sie mit OK, oder betätigen Sie
.
die RETURNTASTE
Dieser Menüpunkt bewirkt, daß den unterschiedliAbbildung 3.17
chen Farben der Sprachelemente beim Drucken
bestimmte Attribute (fett, kursiv oder unterstrichen) zugewiesen werden.
Das Dialogfenster DRUCKERINSTALLATION
Im Eingabefeld KOMMANDOZEILEN-PARAMETER können Sie einen anderen Drucker installieren. Informationen
dazu finden Sie in Ihrem Handbuch.
Notizen
56
3.8. Fehlersuche und Fehlerbehebung
Fehlerarten
Während Sie Ihr Quellprogramm schreiben und testen, treten häufig Fehler auf, beispielsweise beim Compilieren oder während der Programmausführung. Die möglichen
Fehler, die auftreten können, lassen sich in drei Gruppen gliedern.
Syntaxfehler
Laufzeitfehler
Logische Fehler
Syntaxfehler
Diese Fehler treten bereits während der Compilierung eines Quellprogramms auf, wenn Sie sich nicht an die
Syntax von Turbo Pascal halten. Ein Quellprogramm kann nicht compiliert werden, wenn es fehlerhafte Anweisungen enthält.
B
eispiel:
ý
ý
ý
ý
Sie benutzen Variablen, Konstanten oder andere Bezeichner, die Sie nicht deklariert
haben oder bereits als Programmierwörter existieren.
Sie haben Sonderzeichen (Semikolon, Punkt) vergessen, die Sie nach jeder Anweisung
setzen müssen.
Eine Variable oder ein Schlüsselwort ist falsch geschrieben.
Sie führen Rechenoperationen mit unterschiedlichen Datentypen durch, die nicht miteinander vereinbar sind.
Wenn der Compiler während des Compiliervorgangs solche Fehler erkennt, bricht er den Übersetzungslauf ab.
Der Cursor steht an der Stelle des aufgetretenen Fehlers, der am oberen oder unteren Rand des Editor-Fensters
beschrieben wird. Der eigentliche Fehler kann jedoch auch einige Zeilen weiter oben liegen. Die Fehlermeldung
hat folgenden Aufbau:
FEHLER Fehlernummer : Kurzbeschreibung des Fehlers.
Hinter der Information FEHLER folgt eine Fehlernummer. Jede
Fehlermeldung ist mit einer Nummer versehen, die das Suchen im
Hilfesystem und im Handbuch vereinfacht. Wenn Sie weitere Erläuterungen zu der Fehlermeldung haben möchten, können Sie im
Hilfesystem (siehe Abschnitt 3.9) oder im Handbuch nach der entsprechenden Nummer suchen und sich weitere Informationen anzeigen lassen. Hinter der Fehlernummer wird eine Kurzbeschreibung des Fehlers ausgegeben, die oft für die Korrektur des Fehlers
ausreichend ist. Um das Hilfesystem zu aktivieren:
⇒
Betätigen Sie die F1 -Taste, während Sie die FehlermelAbbildung 3.18
dung am Bildschirm sehen.
Fehlermeldung während des
Compilierens
Ein Hilfefenster wird geöffnet, und Sie sehen zu Ihrer Fehlermeldung eine weitere Erläuterung, die Ihnen zur Behebung dieses
Fehlers nützlich sein kann.
⇒
Nachdem Sie die Erläuterung gelesen haben, schließen Sie
das Hilfefenster wieder, indem Sie mit der linken Maustaste
auf das Schließfeld klicken oder die Tastenkombination
ALT F3 betätigen.
⇒
Nach der Korrektur Ihres Quellprogramms rufen Sie erneut
den Menüpunkt COMPILER - COMPILIEREN auf, oder Abbildung 3.19 Hilfefenster bei Fehlermeldung
betätigen Sie die Tastenkombination ALT F9 , um den
Compiliervorgang noch einmal zu starten.
Wiederholen Sie diese Schritte bis keine Syntaxfehler mehr auftreten. Nach fehlerfreier Übersetzung erscheint
dann das Statusfenster aus Abbildung 2.15.
57
Laufzeitfehler
Nachdem Sie alle Syntaxfehler beseitigt haben, wird das Programm durch den Menüpunkt START - AUSFÜHREN oder der Tastenkombination STRG F9 ausgeführt. Tritt während des Programmlaufs ein Fehler auf, wird
das Programm abgebrochen, bevor das logische Programmende erreicht ist. Dies bezeichnet man als Laufzeitfehler. Im Gegensatz zu Syntaxfehlern treten Laufzeitfehler nicht schon bei der Compilierung auf, sondern erst bei
der Ausführung eines Programms.
B
eispiel:
ý
ý
ý
Sie haben ein Programm geschrieben, das eine Tabelle am Drucker ausgeben soll. Der
Drucker enthält jedoch, während Sie das Programm ausführen, kein Papier.
Das Programm möchte auf eine Datei zugreifen, die nicht existiert.
Das Programm versucht, eine Zahl durch Null zu dividieren.
Der Compiler erkennt den Fehler während des Compiliervorgangs nicht. Die Fehlermeldung wird nach dem Programmabbruch am Bildschirm angezeigt:
RUNTIME ERROR Fehlernummer AT: Befehlsadresse
Nach der Information RUNTIME ERROR (= engl. Bezeichnung für Laufzeitfehler) folgt die Fehlernummer, unter der im Hilfesystem und im
Handbuch weitere Erläuterungen zur Fehlermeldung stehen. Die Befehlsadresse gibt an, wo sich der Fehler im ausführbaren Maschinenprogramm befindet. Der Cursor steht im Quellprogramm an der Stelle des
aufgetretenen Fehlers, der am oberen rechten Rand des Editor-Fensters
beschrieben wird. Sie haben hier wiederum die Möglichkeit durch Betätigen der F1 -Taste ein Hilfefenster zu öffnen, das eine Beschreibung der
Fehlermeldung anzeigt. Ändern Sie Ihr Quellprogramm, compilieren Sie
es, und führen Sie es erneut aus. Ihre Laufzeitfehler sind behoben, wenn
das Programm bis zum normalen bzw. logischen Programmende durchgeführt wurde.
Abbildung 3.20
Logische Fehler
Fehlermeldung während der Laufzeit
Logische Fehler sind Fehler, die Turbo Pascal nicht erkennt. Diese Art von Fehlern liegt in der Strukturierung
und Logik des Programmablaufs. Sie werden nicht wie Syntaxfehler oder Laufzeitfehler am Bildschirm angezeigt. Das Programm wird fehlerfrei compiliert und ausgeführt. Die Ausführung des Programms ist jedoch anders
als es vom Programmierer geplant war, beispielsweise wenn der Programmablauf nicht dem logischen Ablauf der
Problemlösung entspricht. Um solche Fehler zu verringern, sollten Sie für jedes Programm eine systematisch
strukturierte Vorplanung durchführen, wie sie in Kapitel 14 beschrieben wird.
B
eispiel:
Sie haben ein Programm geschrieben, das zwei Zahlen multiplizieren soll, die über die Tastatur eingegeben wurden. Das Programm wird durchgeführt, liefert Ihnen aber ein falsches
Ergebnis.
Die Ursachen hierfür können in einer unzureichenden Problemanalyse liegen. Wichtig: Überprüfen Sie Ihre Programme auf logische Richtigkeit, indem Sie beispielsweise bei Rechenoperationen eine manuelle Berechnung
durchführen und das Ergebnis mit dem Computerergebnis vergleichen. Stimmen diese Ergebnisse nicht überein,
überprüfen Sie die einzelnen Programmschritte Ihres Programms.
Notizen
58
B
eispiel:
Folgende logische Fehlerursachen sind möglich:
Vertauschen von Variablen bei einer Wertzuweisung
ý
Betrag := 20;
Wert := 34;
Betrag := Wert;
Rechnung := Betrag * 2;
Hier wird der Variablen Betrag der Inhalt der Variablen Wert zugeordnet. Der Inhalt der
Variablen Betrag ist danach 34. Die Ergebnisvariable Rechnung hat hier den Wert 68.
Betrag := 20;
Wert := 34;
Wert := Betrag;
Rechnung := Betrag * 2;
ý
ý
In diesem Fall ist die Wertzuweisung Betrag := Wert vertauscht worden in Wert :=
Betrag. Der Inhalt der Variablen Rechnung beträgt dann 40.
Variablen, die einen Anfangswert erhalten sollen, sind nicht oder falsch initialisiert
worden.
Die Reihenfolge der Arbeitsschritte im Anweisungsteil stimmt nicht oder es wurden
Arbeitsschritte vergessen.
Übung
Schreiben Sie das folgende fehlerhafte Programm UMSATZ1, genau so wie es hier dargestellt ist, compilieren
und testen Sie es. Versuchen Sie alle Fehler zu beheben. Denken Sie dabei nicht nur an Syntax- und Laufzeitfehler, sondern auch an logische Fehler. Dieses Programm soll den durchschnittlichen Umsatz der Regionen Nord,
Süd, West und Ost berechnen.
PROGRAM Durchschnittlicher Umsatz;
VAR Nord, Sued, West, Ost, DUmsatz : Real
Region : Integer;
BEGIN
WriteLn ('Wie hoch war der Umsatz der Region Nord in DM?');
ReadLn (Nord);
WriteLn ('Wie hoch war der Umsatz der Region Süd in DM?' );
ReadLn (Süd);
WriteLn ('Wie hoch war der Umsatz der Region West in DM? ');
ReadLn (West);
WriteLn ('Wie hoch war der Umsatz der Region Ost in DM? ');
ReadLn (Ost);
DUmsatz := Nord + Süd + West + Ost / Region;
WriteLn ('Der durchschnittliche Umsatz beträgt in DM: ,DUmsatz:8:2,);
END
3.9.
Das Hilfesystem von Turbo Pascal
Mit dem Menüpunkt ? öffnen Sie ein Menüfenster, mit dem Sie sich Hilfsinformationen zu Menüpunkten, zu
Programmierwörtern, Compiler-Befehlen, Fehlermeldungen und vieles mehr anzeigen lassen können.
59
Der Umgang mit dem Hilfesystem
Viele Hilfefenster besitzen farblich hervorgehobene Schlüsselwörter.
Durch einen Doppelklick auf ein Schlüsselwort oder durch Markieren
des Schlüsselwortes mit der
-Taste und anschließendem Bestätigen
RETURNTASTE
können Sie sich zusätzliche Hilfestellungen in
mit der
einem weiteren Fenster anzeigen lassen.
Mit dem Menüpunkt ? - VORHERIGES THEMA oder mit der Tastenkombination ALT F1 gelangen Sie wieder zum Hilfefenster zurück, das
Ihre zuvor gewählte Hilfestellung enthält.
Abbildung 3.21
Das Hilfemenü
Die kontextbezogene Hilfe
Innerhalb von Turbo Pascal können Sie von jeder beliebigen Stelle aus direkt Hilfestellungen zur gerade eingeleiteten Arbeit oder zum markierten Menüpunkt bzw. dem aktiven Dialogfenster anfordern. Deshalb wird diese Art
der Hilfe als kontextbezogene Hilfe bezeichnet.
⇒
Betätigen Sie hierzu die Funktionstaste F1 .
oder Klicken Sie in der Statuszeile F1 HILFE an.
Im Gegensatz zur normalen Hilfe werden die Hilfetexte bei der kontextbezogenen Hilfe in Dialogfenstern angezeigt. Die Anzeige kann hierbei über Befehlsschalftlächen gesteuert werden.
Das sprachbezogene Hilfesystem
Sie können sich zu einzelnen Begriffen (Programmierwörter, Prozeduren, Funktionen, ...), die Sie im Quellprogramm verwenden, Hilfetexte anzeigen lassen, in denen Verwendungsmöglichkeiten, Beispiele und weitere
nützliche Informationen enthalten sind.
⇒
Plazieren Sie den Cursor auf den Begriff, zu dem Sie einen Hilfetext wünschen.
⇒
Wählen Sie den Menüpunkt ? - SUCHE ÜBER SCHLÜSSELWORT, oder betätigen Sie die F1 -Taste. Es
öffnet sich ein Fenster, das Informationen zu dem Begriff enthält, auf dem sich Ihr Cursor befindet.
Falls zu diesem Begriff kein Hilfetext existiert, öffnet sich ein Fenster, das den Hilfe-Index enthält. Dort ist bereits das Stichwort markiert, das dem gesuchten Begriff am nächsten kommt. Durch Doppelklick auf das Stichwird der entsprechende Hilfewort oder durch Markieren des Stichwortes und Betätigen der RETURNTASTE
text oder eine weitere Liste mit Stichwörtern angezeigt.
Das Hilfesystem beenden
⇒
Betätigen Sie die ESC -Taste.
oder Schließen Sie das Hilfefenster durch Anklicken des Schließfeldes.
oder Klicken Sie mit der linken Maustaste auf eine Stelle außerhalb des Hilfefensters.
Notizen
60
Die Hilfe-Menüpunkte im Überblick
Inhalt
Es wird ein Inhaltsverzeichnis gezeigt, das einen Überblick über die Hilfethemen enthält. Durch Doppelklick auf ein Hilfethema können Sie sich nähere Informationen zu diesem Thema anzeigen lassen.
Index
Es erscheint ein Fenster mit einer Stichwortliste. Durch Doppelklick auf ein
Stichwort oder durch Markieren des Stichwortes und Betätigen der
RETURNTASTE
wird der entsprechende Hilfetext oder eine weitere Liste mit
Stichwörtern angezeigt.
Suche über Schlüsselwort
Hiermit läßt sich die kontextbezogene Hilfe aufrufen.
Vorheriges Thema
Sie gelangen wieder zu dem Hilfefenster, das Sie zuvor gewählt haben.
Hilfe verwenden
Dieser Menüpunkt gibt Ihnen Informationen zur Bedienung der Hilfefunktion.
Dateien installieren
Hier können Sie zusätzliche Hilfedateien in das Turbo Pascal-Hilfesystem hinzufügen.
Compiler-Befehle
Es wird Ihnen eine Liste mit Compiler-Befehlen angezeigt. Sie können sich zu
diesen Befehlen weitere Informationen anzeigen lassen, indem Sie den gewünschten Befehl auswählen.
Prozeduren und Funktionen Es erscheint eine Liste mit Prozeduren und Funktionen, die Sie für weitere Erläuterungen auswählen können. Dieses Hilfefenster ist jedoch nicht in jeder
Version von Turbo Pascal verfügbar.
Reservierte Wörter
Hier können Sie sich einen Index mit allen reservierten Wörtern von Turbo
Pascal anzeigen lassen. Sie haben hier auch die Möglichkeit, durch Auswählen
eines Wortes sich eine detaillierte Beschreibung anzeigen zu lassen.
Standard-Units
Hier werden Ihnen die Standard-Units angezeigt. Weitere Informationen erhalten Sie durch Auswahl einer Unit.
Sprachspezifikation
Eine Liste des gesamten Sprachumfangs können Sie sich hier anzeigen lassen.
Durch Auswahl eines Elementes werden Ihnen weitere Informationen angezeigt.
Fehlermeldungen
Hier erscheint eine Liste der Fehlermeldungen gruppiert nach den Fehlernummern, die Ihnen Turbo Pascal mit der Fehlermeldung am Bildschirm ausgibt.
Anhand der Fehlernummer können Sie sich leicht eine detaillierte Beschreibung
zu Ihrer Fehlermeldung anzeigen lassen, um mögliche Ursachen zu erkennen.
Info über Turbo Pascal
Ein Dialogfenster öffnet sich mit der Versionsnummer und Copyright-Meldung
von Turbo Pascal.
Nützliche Tastenkombinationen zum Arbeiten mit dem Hilfesystem
Zeigt die kontextbezogene Hilfestellung an.
F1
STRG
ñ
Umschalten
ALT
Zeigt eine sprachbezogene Hilfestellung an.
F1
F1
F1
Zeigt den Index des Hilfesystems an.
Zeigt die zuletzt gewählte Hilfestellung an.
Notizen
61