In den vorangegangenen Abschnitten trat bereits der Begriff Typ auf: Zahlen wurden unterschieden in ganze Zahlen und reelle Zahlen, Variablen wurden bei der Deklaration an einen Typ gebunden, und Ausdrücke besaßen einen Typ. Falls Sie bereits in BASIC programmiert haben, wissen Sie, daß es dort nur zwei Typen gibt: Reelle Zahlen und Strings. Einige BASIC-Dialekte erlauben auch eine Unterscheidung zwischen ganzen und reellen Zahlen. Die Typen von Variablen gehen in BASIC aus dem Suffix des Variablennamens hervor (»$« oder »%«).
In Pascal gibt es auch Objekte ganz anderer Typen. Später werden Sie sogar lernen, wie man eigene Typen in Pascal definiert (Abschnitt 2.12). Dieser Abschnitt beschäftigt sich mit den elementaren Standardtypen. Diese Typen besitzen in Pascal vordefinierte Namen:
| Typname | Wertebereich | Beispielwerte des Typs |
| INTEGER | Ganze Zahlen | 0 -7 500 3256 |
| REAL | Reelle Zahlen | 3.250.0-5E-13 |
| CHAR | Einzelzeichen | 'A' 'O''&' |
| STRING | Zeichenketten | 'Alpha' '12345678' |
| BOOLEAN | Wahrheitswerte | TRUE FALSE |
Nachfolgend werden die Eigenschaften jedes Typs im einzelnen besprochen, und die Operationen mit Objekten dieser Typen vorgestellt.
Werte vom Typ INTEGER sind ganze Zahlen, also positive und negative Zahlen ohne Nachkommastellen. Die wichtigsten Operationen, die auf ganze Zahlen anwendbar sind, liefern als Ergebnis wieder eine ganze Zahl:
| + | Identität oder Addition | +73 + 4 |
| - | Subtraktion oder Vorzeichenwechsel | -31 - 4 |
| * | Multiplikation | 12 * 43 |
| DIV | ganzzahlige Division | 44 DIV 13 |
| MOD | Modulo-Bildung (Divisionsrest) | 44 MOD 13 |
Um die Wirkungsweise der letzten beiden Operationen zu verdeutlichen, folgen noch einige Zahlenbeispiele:
10 DIV 3 = 3 10 MOD 3 = 1 (-10) DIV 3 = -3 (-10) MOD 3 = -1 10 DIV (-3) = -3 10 MOD (-3) = 1 (-10) DIV (-3) = 3 (-10) MOD (-3) = -1
X DIV Y ist also der ganzzahlige Anteil des Quotienten X/Y. X MOD Y ist gleich dem Rest der Division X DIV Y. Formal hängen DIV und MOD folgendermaßen zusammen:
X = (X DIV Y) * Y + (X MOD Y)
Weiterhin existiert die arithmetische Funktion ABS(n), die den Absolutwert (Betrag) der Zahl n liefert:
ABS(3) = 3ABS(-3) = 3ABS(0) = 0
Jeder Computer kann nur Zahlen einer endlichen Größe darstellen. In Pascal 2.0 sind als ganze Zahlen nur Werte mit
-MAXINT-1<= N <= MAXINT
zugelassen. MAXINT ist der vordefinierte Name für eine Konstante mit dem Wert
MAXINT = 32767
Tritt bei einer der obigen Operationen mit ganzen Zahlen eine Bereichsüberschreitung auf, so meldet dies das Pascal-Laufzeitsystem und unterbricht das laufende Programm:
PROGRAM UEBERLAUF(INPUT,OUTPUT); BEGIN WRITELN(1000*1000 DIV 1000); END.
Obwohl das Endergebnis eine gültige INTEGER-Zahl ist, wird während der Berechnung der darstellbare Zahlenbereich verlassen, was der Computer mit folgender Meldung quittiert:
INTEGER OVERFLOW ERROR AT 7418 IN UEBERLAUF
Werte des Typs REAL sind reelle Zahlen. Die arithmetischen Operationen (+, -, *, /) liefern angewandt auf reelle Zahlen ein Ergebnis vom Typ REAL. Der Schrägstrich »/« liefert also das normale Ergebnis einer Division:
1.5 / 1.2 = 1.25
Andererseits dürfen die Operationen MOD und DIV nicht auf Werte vom Typ REAL angewendet werden. Weiterhin sind alle üblichen arithmetischen Funktionen in Pascal definiert. Sie liefern jeweils ein Ergebnis vom Typ REAL:
| Name in Pascal | Operation | Name in BASIC |
| ABS | Absolutwert | ABS |
| SQRT | Quadratwurzel | SQR |
| EXP | Exponentialfunktion | EXP |
| LN | natürlicher Logarithmus | LOG |
| SIN | sinus | SIN |
| COS | cosinus | COS |
| ARCTAN | arcus tangens | ATN |
| SQR | Quadrat | --- |
Die trigonometrischen Funktionen sind für Winkel in Bogenmaß definiert. Wollen Sie mit Winkeln in Grad arbeiten, so müssen Sie zunächst eine Umrechnung vornehmen. Es gilt:
180 Grad = PI rad
Die simple Dreisatzrechnung zur Umrechnung sieht in Pascal folgendermaßen aus:
PROGRAM WINKEL (INPUT, OUTPUT);
VAR X, T: REAL;
FAKTOR1: REAL;
BEGIN
WRITE('Winkel (in Grad):'); READLN(X);
FAKTOR1:= 1.74532925E-2; (* das ist PI/180 *)
WRITELN('SIN(',X :5 :2,') =', SIN(X * FAKTOR1));
WRITELN;
WRITE('Tangens:'); READLN(T);
WRITE('Der Winkel ', ARCTAN(T) / FAKTOR1 :5 :2);
WRITELN(' besitzt den Tangens', T);
END.
Zusätzlich zu den in der Tabelle aufgeführten Funktionen existieren in Pascal 2.0 zwei weitere Funktionen, die nicht im report vorgesehen sind. Beide Funktionen liefern ein Ergebnis vom Typ REAL:
POWER(x,y): Diese Funktion berechnet x hoch y für beliebige reelle Zahlen x und y. Die Berechnung ist recht aufwendig und erfolgt intern nach der Formel:
POWER (x,y) = EXP(y * LN(x))
Daher ist für kleine ganzzahlige y eine Berechnung durch mehrmalige Multiplikation schneller. Also
X*X*X statt POWER (X,3)
TAN(x): Diese Funktion berechnet den Tangens des Winkels x in Bogenmaß.
Jede Implementierung setzt auch eine Grenze für den Zahlenbereich, in dem reelle Zahlen dargestellt werden können. Um die Ergebnisse von Operationen mit reellen Zahlen zu verstehen, muß man die interne Darstellung von Werten des Typs REAL kennen.
Würde man sich z.B. darauf einigen, daß von jeder reellen Zahl 8 Stellen vor dem Komma und 4 Nachkommastellen gespeichert werden, so bestünde der darstellbare Zahlenbereich aus den Zahlen zwischen
-999999999.9999
+999999999.9999
Dabei müßten alle Ziffern, die mehr als vier Stellen hinter dem Komma stehen, ignoriert werden. Offensichtlich bietet eine solche willkürliche Beschränkung auf Vor- und Nachkommastellen für viele Anwendungen keine befriedigende Lösung.
Wie speichert man also so verschiedene Zahlen wie
A = 9876543219876543210 B = 123000000000 C = 0.0000000000234
am günstigsten? Die Idee für eine kompakte Speicherung der Zahlen besteht darin, sich zunächst die Größenordnung der Zahl zu merken: A besitzt 19 Stellen vor dem Komma, B hat 13 Vorkommastellen, während C an der 12. Stelle hinter dem Komma beginnt. Außerdem werden von jeder Zahl die ersten sogenannten signifikanten Stellen gespeichert.
Beim C-128 kann eine Zahl maximal 38 Stellen vor oder nach dem Komma beginnen. Von jeder Zahl werden jedoch maximal 9 Ziffern gespeichert. An der neunten Stelle wird gerundet. Intern wird jede reelle Zahl durch zwei Werte (Mantisse und Exponent) dargestellt:
Mantisse Exponent
A = 0.987654322 E +19
B = 0.123000000 E +12
C = 0.234000000 E -10
Die Länge der Mantisse bestimmt also die Genauigkeit einer Zahlendarstellung, während die Größe des Exponenten die maximale Größe der darstellbaren Zahlen begrenzt. Für den C-128 gelten folgende rechnerspezifsichen Regeln:
Diese Grenzen werden in der Praxis mit einem Heimcomputer nie überschritten, außer man wollte z.B. DM-Beträge über 9 Millionen auf den Pfennig genau speichern. Problematisch ist aber nicht die Speicherung der Zahlen, sondern das Rechnen mit REAL-Zahlen. Da auch alle Zwischenergebnisse nur auf neun Stellen genau sind, liefern scheinbar harmlose Berechnungen falsche Ergebnisse:
Mit den obigen Zahlen ist zum Beispiel C + B - B nicht gleich C, da der Computer folgendermaßen rechnet:
C + B - B = (C + B) - B = 1.23E+11 - 1.23E+11 = 0
Bei Berechnungen mit REAL-Zahlen sollte man sich solcher Ungenauigkeiten immer bewußt sein, und zuerst Werte der gleichen Größenordnung verknüpfen. Besonders kritisch sind Vergleiche zwischen reellen Zahlen. Man sollte deshalb nie auf Gleicheit zweier reeller Zahlen prüfen:
IF A = B THEN ....(falsch!)
Besser prüft man, ob die Differenz zwischen A und B innerhalb einer durch die Rundungsfehler gegebenen Toleranzzone liegt:
IF ABS(A-B) <= 1E-7 THEN ...(besser!)
Solange alle Zwischenergebnisse in dem durch die Konstante MAXINT angegebenen Bereich liegen, sind Operationen mit Werten vom Typ INTEGER im mathematischen Sinn exakt. Außerdem werden ganze Zahlen kompakter als reelle Zahlen gespeichert. In Pascal 2.0 benötigt eine ganze Zahl nur zwei Speicherstellen gegenüber fünf Speicherstellen für reelle Zahlen. Nicht zuletzt sind INTEGER-Operationen wesentlich effizienter (kürzerer Code, höhere Ausführungsgeschwindigkeit) als solche mit reellen Zahlen.
PROGRAM SPEED (INPUT,OUTPUT);
(* Dieses Programm zeigt die Geschwindigkeitsunterschiede *)
(* zwischen Operationen mit reellen und ganzen Zahlen *)
VAR ZAEHLER: INTEGER;
I : INTEGER;
R : REAL;
BEGIN
WRITELN('Schleife (REAL) gestartet' #7);
R:=0;
FOR ZAEHLER:= 0 TO 1000 DO
R:= (ZAEHLER - R) / 2;
WRITELN('Schleife (INTEGER) gestartet' #7);
I:= 0;
FOR ZAEHLER:= 0 TO 1000 DO
I:= (ZAEHLER - I) DIV 2;
WRITELN('Schleife beendet' #7);
WRITELN('Ergebnisse:', R, I);
END.
Andererseits können große Zahlen nur mit Werten vom Typ REAL dargestellt werden. Auch alle höheren Funktionen liefern Werte vom Typ REAL als Ergebnisse.
Zusammenfassend läßt sich sagen, daß reelle Zahlen nur in mathematischen Anwendungen (Nullstellenbestimmungen, statistische Auswertungen etc.) und in kaufmännischen Programmen zur Darstellung großer Zahlen verwendet werden. Typische Anwendungen für ganze Zahlen sind hingegen Steuerungsaufgaben im Programm wie Zähler, Indizes und Laufvariablen. Nicht umsonst sind mindestens zwei Drittel aller Variablen in typischen Pascalprogrammen vom Typ INTEGER.
Während Sie schon einige Fälle kennengelernt haben, in denen keine REAL-Werte zulässig sind, nämlich als Feldgröße bei WRITE oder als Operand bei den Operatoren DIV und MOD, können umgekehrt überall dort, wo reelle Zahlen erlaubt sind, auch ganze Zahlen stehen. Der Compiler erzeugt an diesen Stellen Code zur Umwandlung in die Darstellung mit Mantisse und Exponent.
SIN(3) 3/4 SQRT(2)
Eine solche Umwandlung von INTEGER- in REAL-Zahlen erfolgt auch bei den folgenden gemischten Ausdrücken, bei denen eine INTEGER- Zahl mit einer reellen Zahl verknüpft wird:
3 + 4.0 1 + 2 + 4 * 20.7
Das Ergebnis eines gemischten Ausdruckes ist immer vom Typ REAL.
Die umgekehrte Umwandlung von reellen Zahlen in ganze Zahlen muß explizit programmiert werden, damit festgelegt werden kann, wie die Nachkommastellen behandelt werden. In Pascal sind dazu die Funktionen ROUND und TRUNC vorhanden. ROUND(x) rundet das reelle Argument, während TRUNC nur die Nachkommastellen abschneidet. Pascal 2.0 bietet zusätzlich die Funktion INT, die das reelle Argument zur nächst kleineren ganzen Zahl abrundet. Beispiele zeigen am besten die unterschiedlichen Ergebnisse:
ROUND( 3.2) = 3 TRUNC( 3.2) = 3 INT( 3.2) = 3 ROUND( 3.7) = 4 TRUNC( 3.7) = 3 INT( 3.7) = 3 ROUND(-3.2) = -3 TRUNC(-3.2) = -3 INT(-3.2) = -4 ROUND(-3.7) = -4 TRUNC(-3.7) = -3 INT(-3.7) = -4
Nur ein geringer Teil aller Programme arbeitet ausschließlich mit Zahlen. Eine Klasse von Objekten, die vor allem bei der Kommunikation des Rechners mit seiner Umwelt eine große Rolle spielen, sind Zeichen.
Werte des Typs CHAR (character) sind einzelne Zeichen. Jedes Zeichen besitzt eine Ordnungsnummer (Codenummer). Der Zusammenhang zwischen Zeichen und Ordnungsnummer ist leider vom jeweiligen Rechner abhängig. Speziell auf Commodore-Rechnern gibt es 256 verschiedene Zeichen. Eine Variable vom Typ CHAR kann also genau eines dieser 256 Zeichen speichern. Nur 160 dieser Zeichen sind auch am Bildschirm darstellbar. Die restlichen Zeichen (Kontrollzeichen) erfüllen spezielle Aufgaben bei den einzelnen Geräten.
So besitzen die Cursortasten bei Tastatureingaben ein eigenes Zeichen, mit einigen Zeichen läßt sich bei der Bildschirmausgabe die Zeichenfarbe wählen, und wieder andere Zeichen wählen den Schrifttyp am Drucker.
Konstanten vom Typ CHAR sind Stringkonstanten (s. Definition in Abschnit 2.1) der Länge 1:
'.', '*', 'A', #147 und 'x'
Vergleiche sind die einzigen Operationen, die zwischen Zeichen definiert sind. Das Ergebnis eines Vergleichs zweier Zeichen ist durch ihre Ordnungszahl festgelegt. Eine Liste aller Ordnungszahlen findet sich im Anhang A des BASIC-Handbuchs. Auf Commodore-Rechnern gilt also:
'A' < 'Z' '0' < '9' '!' < ')' 'b' < 'B'
Der letzte Vergleich ist besonders verwirrend, da auf einem Commodore-Computer Kleinbuchstaben nur durch Umschaltung der Bildschirmdarstellung erreicht werden können. Dann besitzen die mit der SHIFT-Taste eingegebenen Großbuchstaben eine höheren Codenummer als die normal eingegebenen Kleinbuchstaben.
Innerhalb eines Pascalprogrammes können Sie die Ordnungsnummer jedes Zeichens mit der Standardfunktion ORD erhalten:
ORD('A') = 65 ORD('Z') = 90
ORD('0') = 48 ORD('9') = 57
ORD('!') = 33 ORD(')') = 41
ORD('b') = 66 ORD('B') = 194
Die Umkehrung der Funktion ORD ist die Funktion CHR: Sie liefert zu einem Argument vom Typ INTEGER das Zeichen mit der angegebenen Ordnungsnummer:
CHR(65) = 'A' CHR(57) = '9'
Diese Umwandlung zwischen Zeichen und Ordnungsnummer ist, wie bereits erwähnt wurde, vom zugrundeliegenden Zeichensatz abhängig. Jedoch können Sie davon ausgehen, daß auf jedem Rechner die Zahlen und Buchstaben zusammenhängend aufsteigend geordnet sind, so daß '0'<'9' und 'A'<'Z' ist. Eine recht häufige Anwendung dieser Umwandlungsroutinen ist der selektive Zugriff auf einzelne Ziffern einer Zeichenfolge. Das folgende Beispielprogramm berechnet die Quersumme einer zweistelligen Zahl, die der Benutzer eingibt:
PROGRAM QUERSUME (INPUT,OUTPUT);
VAR ZIFFER1,ZIFFER2: CHAR;
WERT1, WERT2 : INTEGER;
BEGIN
READLN(ZIFFER1, ZIFFER2);
WERT1:= ORD(ZIFFER1) - ORD('0');
WERT2:= ORD(ZIFFER2) - ORD('0');
WRITELN('Quersumme ', WERT1 + WERT2);
END.
Durch die Möglichkeit von Pascal 2.0, auch Steuerzeichencodes als Zeichenkonstanten zu definieren, könnten Sie z.B. mit dem folgenden kleinen Programm die Cursortasten abfragen. Dabei werden alle Möglichkeiten zur Umwandlung zwischen den Typen INTEGER und CHAR verwendet. Die »Befehle« REPEAT und UNTIL bewirken eine Wiederholung der eingerückten Befehle, bis die Abbruchbedingung hinter UNTIL zutrifft. Es werden also solange Eingaben von der Tastatur mit dem »Befehl« GETKEY gelesen, bis der Benutzer die RETURN-Taste betätigt.
PROGRAM TASTATURABFRAGE (INPUT,OUTPUT);
(* Die RETURN-Taste besitzt den Code 13 *)
VAR CH: CHAR;
BEGIN
WRITELN('Tastaturabfrage mit GETKEY (Ende mit RETURN)');
REPEAT
GETKEY(CH);
IF CH = CHR(29) THEN WRITE ('Cursor rechts');
IF ORD(CH) = 157 THEN WRITE ('Cursor links');
WRITE(CH);
UNTIL CH = #13; (* RETURN-Taste betätigt *)
WRITELN('Programm beendet.');
END.
Zur Steuerung des Programmablaufs in Abhängigkeit von bestimmten Bedingungen sind Wahrheitswerte erforderlich. Wahrheitswerte werden in Pascal durch TRUE (wahr) und FALSE (falsch) beschrieben. Formal sind TRUE und FALSE Konstanten des Typs BOOLEAN. Viele Operationen liefern Wahrheitswerte als Ergebnis. Die Relationen zwischen Zahlen und Zeichen wurden bereits angesprochen:
(17 = 0) FALSE 'X' < 'Y' TRUE (17 > 0) TRUE '!' < 'A' TRUE (0.5=5E-1) TRUE 'X' = 'x' FALSE
Ein weiteres Beispiel ist die Funktion ODD(n), die den Wert TRUE liefert, falls das Argument n ungerade ist:
ODD(3) TRUE ODD(16) FALSE ODD(0) FALSE
Gibt man bei der Deklaration einer Variablen den Typ BOOLEAN, so kann man ihr die Ergebnisse solcher Vergleiche zuweisen. Boolesche Variablen können natürlich ihrerseits wieder in Ausdrücken auftauchen. Sind B1 und B2 zwei logische Ausdrücke, so kann man mit den logischen Operatoren AND, OR, NOT neue Ausdrücke bilden:
B1 AND B2 TRUE, falls B1=TRUE und B2=TRUE ist B1 OR B2 TRUE, falls B1=TRUE oder B2=TRUE ist NOT B1 TRUE, falls B1=FALSE ist
Wenn Sie jetzt wieder einmal die Syntaxdiagramme im Anhang A (EINFACHER AUSDRUCK und TERM) betrachten, werden Sie feststellen, daß dort diese logischen Operatoren mit den arithmetischen Operatoren (+, -, * etc.) aufgeführt sind. AND ist ein Multiplikationsoperator und bindet daher stärker als der Additionsoperator OR. NOT ist hingegen wie ein Vorzeichen definiert.
Diese Definition unterscheidet Pascal von vielen anderen Sprachen, da hierdurch AND, OR und NOT stärker binden als die Relationen =, >, < etc. Das folgende Beispielprogramm zeigt sowohl kompliziertere boolesche Ausdrücke, als auch die Verwendung boolescher Variablen und die Ausgabe von Wahrheitswerten.
PROGRAM BOOL (INPUT,OUTPUT);
VAR P,Q : BOOLEAN;
ALLESFALSCH, ZUGROSS : BOOLEAN;
I, J : INTEGER;
BEGIN
READLN(I,J);
P:= TRUE; WRITELN(P);
Q:= I>J; WRITELN('I>J ', Q);
WRITELN('BEIDE UNGERADE: ', ODD(I) AND ODD(J));
P:= (I=J) OR Q;
ALLESFALSCH:= NOT P AND NOT Q;
ZUGROSS:= (I>500) OR (J>500);
WRITELN(P, ALLESFALSCH, ZUGROSS);
IF P AND ALLESFALSCH OR (I=0) THEN
WRITELN('Dieser Text wird nur ausgegeben, falls I=0 ist');
END.
Sie sehen also, daß man mit wenigen Operationen, die boolesche Variablen beinhalten, sehr undurchsichtige Bedingungen formulieren kann. Um die exakten Ausgaben für beliebige Werte von I und J vorherzusagen müssen Sie sicher noch einmal die Prioritätsregeln für die Operatoren AND, OR und NOT studieren.
Sehr wichtig ist die Tatsache, daß Teilausdrücke, die Vergleiche enthalten, innerhalb boolescher Ausdrücke geklammert werden müssen. Man schreibt also:
(I=J) OR (I<>K) und nicht I=J OR I<>K
da der Compiler OR wie einen Additionsoperator behandelt und daher den zweiten Ausdruck implizit folgendermaßen klammern würde:
I = (J OR I) <> K
Das Beispielprogramm verdeutlicht auch eine Namenskonvention: Man bezeichnet boolesche Variablen meist mit Adjektivnamen, die den Wahrheitswert symbolisieren, den die Variable speichert:
ZUGROSS:= (I>500) OR (J>500)
Nur selten wird die Tatsache ausgenutzt, daß die Funktion ORD auch auf boolesche Argumente anwendbar ist. Dadurch ist auch der Typ BOOLEAN geordnet, wobei gilt:
ORD(FALSE) = 0 ORD(TRUE) = 1 und FALSE < TRUE
Eine Bitte am Schluß: Schreiben Sie in einem booleschen Ausdruck nicht
P = TRUE oder ALLESFALSCH = FALSE
Dies ist zwar syntaktisch und semantisch völlig korrekt, zeugt aber von einem schlechten Stil. Man schreibt einfacher und deutlicher:
P oder NOT ALLESFALSCH
Der in diesem Abschnitt vorgestellte Typ gehört nicht zu dem im report definierten Standardsprachumfang. Jedoch wird er von vielen Compilern, für Microcomputer seien nur TURBO-PASCAL und UCSD-Pascal genannt, unterstützt. Mit diesem Quasi-Standard geht auch der auf Diskette mitgelieferte Compiler Pascal 2.0 konform.
Im Gegensatz zu den übrigen in Kapitel 2.6 vorgestellten Typen ist der Typ STRING eigentlich kein elementarer Typ. Ein Wert vom Typ STRING besteht nämlich aus einer variablen Anzahl von Werten des Typs CHAR. Somit sind die folgenden Zeichenketten mit 0, 16 und 10 Zeichen Länge alle vom Typ STRING.
'' '-----> * <-----' 'LAGERREGAL'
Werte des Typs STRING können wie Einzelzeichen auch miteinander verglichen werden. Diese Vergleiche liefern ebenfalls ein Ergebnis vom Typ BOOLEAN:
'MAUS' > 'KATZE' TRUE 'PASCAL' = 'PASCAL ' FALSE 'ANNABELLE' > 'ANNA' TRUE
Ein String S1 ist kleiner als ein String S2, falls er in der üblichen lexikographischen Ordnung vor S2 auftritt. Natürlich ist das Vergleichsergebnis ebenfalls vom zugrundeliegenden Zeichensatz des Computers abhängig. Es ist wichtig zu beachten, daß Leerzeichen in Strings bei Vergleichen berücksichtigt werden. Daher ist 'PASCAL' <> 'PASCAL '. Um die Ergebnisse von Vergleichen auszuprobieren, können Sie das folgende kleine Programm verwenden:
PROGRAM STRINGORDNUNG(INPUT,OUTPUT);
VAR S1,S2: STRING;
BEGIN
READLN(S1);
READLN(S2);
IF S1>S2 THEN
WRITELN(S1, ' > ', S2)
ELSE
WRITELN(S1, ' <=', S2);
END.
Das Programm zeigt auch die Eingabe und Ausgabe von Stringvariablen. In Pascal 2.0 existieren zahlreiche Stringoperationen, die in Kapitel 2.9.2 vorgestellt werden. Dort wird ebenfalls erklärt, wie man gezielt auf einzelne Zeichen (vom Typ CHAR) eines Strings zugreifen kann.
Aufgaben:
1. Prüfen Sie die Bereichsgrenzen für ganze und reelle Zahlen in Pascal 2.0. Welche Fehlermeldungen erhalten Sie? Lokalisieren Sie die Fehler im Quelltext mit der Option LOCATE ADDRESS des Compilers!
2. Wie muß man in Abschnitt 2.6.2 den Ausdruck C+B-B klammern oder umstellen, um ein korrektes Ergebnis zu erhalten?
3. In der Dokumentation ist die Funktion RANDOM(x) von Pascal 2.0 beschrieben, die eine reelle Zufallszahl größer oder gleich Null und kleiner als Eins liefert. Schreiben Sie ein Programm, das ganzzahlige Zufallszahlen berechnet!
3.1 Zunächst simulieren Sie eine Münze, die die Werte 0 und 1 mit gleicher Wahrscheinlichkeit liefert.
3.2 Erweitern Sie den Wertebereich, so daß ein Würfel simuliert wird (Werte 1,2,3,4,5 und 6 gleichwahrscheinlich).
3.3 Wählen Sie eine Formel, durch die folgende Wahrscheinlichkeitsverteilung simuliert wird:
NOT(A AND B) entspricht NOT(A) OR NOT(B) NOT(A OR B) entspricht NOT(A) AND NOT(B)