Zur Speicherung von Texten können Arrays mit dem Elementtyp CHAR verwendet werden. Der Text wird also zeichenweise gespeichert:
VAR A1,A2 : ARRAY[1..8] OF CHAR;
A3 : ARRAY[1..15] OF CHAR;
Diese Arrays bestehen aus acht beziehungsweise fünfzehn Zeichen. Bereits im Abschnitt 2.1 wurden Stringkonstanten beschrieben. Eine Stringkonstante mit N Zeichen Länge besitzt implizit den Typ
ARRAY [1..N] OF CHAR;
Das im report definierte Standardpascal ist bei der Behandlung von Strings sehr restriktiv. Da dort Strings Arrays sind, besitzen sie eine konstante Größe. Deshalb sind in Standardpascal auch nur Zuweisungen zwischen Strings gleicher Länge erlaubt:
A1:= A2; (korrekt) A1:='12345678'; (korrekt) A3:='ALPHA '; (korrekt) A1:= A3; (verboten) A3:= '.....'; (verboten)
Auch Vergleiche zwischen Strings sind im report nur zwischen Strings identischer Länge erlaubt.
'OTTO' < 'OTTO2' (verboten) 'ALPHA' < 'BETA' (verboten)
Um auf ein einzelnes Zeichen eines Strings zuzugreifen kann man ein ARRAY ... OF CHAR wie jedes andere Array indizieren:
FOR I:= 1 TO 8 DO WRITE('!', A1[I]);
Mit dieser For-Anweisung wird der String S1 zeichenweise ausgegeben:
!A!L!P!H!A! ! !
Wie viele Pascal-Implementierungen bietet Pascal 2.0 einen vordeklarierten Typ STRING und einen großen Satz an speziellen String-Prozeduren. Dies ermöglicht die Bearbeitung von Zeichenketten variabler Länge:
VAR S1,S2: STRING;
S3: STRING[16];
Der vordefinierte Typname STRING wurde bereits in Abschnitt 2.6.6 vorgestellt. Dort wurde auch erklärt, daß eine Stringvariable wie S1 und S2 einen String variabler Länge speichern kann. Die Deklaration von S3 zeigt, daß hinter dem Typnamen STRING eine Maximallänge des Strings genannt werden kann. Der Compiler reserviert also für S3 soviel Speicherplatz, daß S3 maximal 16 Zeichen umfassen kann. Bei der Zuweisung
S3:= 'String mit Überlänge!'
wird zur Laufzeit des Programmes folgende Fehlermeldung ausgegeben:
STRING OVERFLOW ERROR
Entfällt die explizite Angabe einer Maximallänge, so darf ein String nicht länger als 80 Zeichen werden. In eckigen Klammern kann eine Maximallänge von bis zu 255 Zeichen pro String vereinbart werden.
Auf Variablen vom Typ String kann wie auf normale Arrays indiziert zugegriffen werden:
S1:= 'Beispiel';
FOR I:= 1 TO LENGTH(S1) DO
WRITE('!', S1[I]);
bewirkt eine zeichenweise Ausgabe des Strings S1:
!B!e!i!s!p!i!e!l
Der Inhalte eines Elementes S[I] mit einem Index I größer als LENGTH(S) ist nicht definiert. Übrigens enthält in Pascal 2.0 das Element S[0] die aktuelle Länge des Strings S in Zeichen. Es gilt also ORD(S[0]) = LENGTH(S).
Jedoch ist der indizierte Zugriff auf Einzelzeichen bei Strings nur selten erforderlich, da spezielle Funktionen und Prozeduren zur Bearbeitung von Strings existieren:
PROGRAM STRINGS (INPUT,OUTPUT);
VAR S1,S2: STRING;
T : STRING;
I : INTEGER;
BEGIN
READLN(S1); READLN(S2);
WRITELN('>',S1,'<');
WRITELN('>',S2:80,'<');
WRITELN('Längen:', LENGTH(S1), LENGTH(S2));
T:= '>' + S1 + S2 + '<';
WRITELN('konkateniert: ', T);
DELETE(T,1,1); DELETE(T,LENGTH(T),1);
WRITELN('gelöscht:', T);
T:= COPY (T, 1, 5);
WRITELN('die ersten 5 Zeichen:', T);
FOR I:= 5 DOWNTO 1 DO
INSERT('.',T,I);
WRITELN('eingefügt:',T);
I:= POS(S1,S2);
IF I=0 THEN
WRITELN(S1, ' ist nicht in ', S2, ' enthalten!')
ELSE
WRITELN('Position von S1 in S2 :', I);
END.
Bild 27: Beispiele für Stringoperationen
Jede der Stringfunktionen und -prozeduren wird ausführlich in Kapitel 4.4.4.7 besprochen. Dort wird insbesondere das Verhalten in Sonderfällen genau besprochen. In diesem Abschnitt wird nur ein Überblick über die zur Verfügung stehenden Operationen gegeben und die grundlegenden Begriffe bei Stringoperationen vorgestellt:
| Stringkonstante | 'Beispiel' |
| Stringvariable | S1 |
| Variable des Typs ARRAY ... OF CHAR | A1 |
| Wert des Typs CHAR | 'X' CH |
| Ergebnis einer vordefinierten Stringoperation | A1 + S1 |
| Ergebnis einer benutzerdefinierten Stringfunktion | COPY(S1,3,4) |
In einem Stringausdruck darf auch kein Zwischenergebnis länger als 255 Zeichen werden. In diesem Fall wird ein »STRING OVERFLOW ERROR« gemeldet.
In Pascal 2.0 können alle Stringoperationen beliebig geschachtelt werden und auch rekursiv beliebig oft aufgerufen werden. Insbesondere können die Funktionen VAL und STR auch innerhalb von WRITE- und READ-Operationen verwendet werden. Diese Eigenschaften werden deshalb so betont, da viele Implementierungen (auch TURBO-PASCAL) einen festen Arbeitsbereich für Stringoperationen besitzen, so daß bei den oben genannten Fällen für den Benutzer unerwartete Resultate auftreten können.
Nachdem nun die Terminologie geklärt ist, können die im Beispielprogramm (Bild 27) verwendeten Operationen kurz angesprochen werden. Sie sollten diese Operationen mit verschiedenen Eingaben S1 und S2 testen und bei Bedarf auch eigene kleine Testprogramme schreiben:
Beim Lesen eines Strings mit READwerden solange Zeichen von der Tastatur gelesen und im String gespeichert, bis der Benutzer die RETURN-Taste betätigt. Bei der Ausgabe mit WRITE gelten die in Abschnitt 2.5.1 aufgeführten Regeln zur Formatierung.
Die Funktion LENGTH liefert zu einem beliebigen Stringausdruck die aktuelle Länge. Das Ergebnis ist eine Zahl vom Typ INTEGER im Bereich 0 bis 255. Eine häufige Operation im Zusammenhang mit Strings ist das Verketten (Konkatenieren) einer Folge von Stringausdrücken. Diese Operation kann einerseits mit dem Pluszeichen (»+«), andererseits aber auch mit der vordefinierten Funktion CONCAT durchgeführt werden. Die Funktion CONCAT existiert in Pascal 2.0 nur, um Programme unverändert übernehmen zu können, die mit anderen Pascal-Compilern entwickelt wurden:
T:= '>' + 'Anna' + 'Otto' + '<'; entspricht
T:= CONCAT ('>', 'Anna', 'Otto','<'); entspricht
T:= '>AnnaOtto<'
Die Länge des Ergebnisstrings ist also gleich der Summe der Teilstrings.
T:='Dies ist ein Test'; DELETE(T,6,3); (* --> T = 'Dies ein Test' *)
Mit diesem Aufruf der Prozedur DELETE werden aus der Stringvariablen T ab dem 5. Zeichen 3 Zeichen entfernt. Vielseitiger ist die Funktion COPY, da sie auch auf Stringausdrücke und nicht nur auf Stringvariablen angewendet werden kann:
WRITELN( COPY ('Dies ist ein Test', 6, 7))
In diesem Beispiel wird aus dem String ab dem 6. Zeichen ein Teilstring der Länge 7 selektiert ('ist ein'). Das Gegenstück zur Prozedur DELETE ist die Prozedur INSERT. Mit ihr kann man einen beliebigen Stringausdruck in eine Stringvariable ab einer frei wählbaren Position einfügen:
S:= 'Hände hoch, Überfall!';
INSERT ('Bank-', S, 13);
(* --> S = 'Hände hoch, Bank-Überfall!' *)
Die Funktion POS bestimmt die Position eines Stringausdruckes in einem anderen Stringausdruck:
WRITELN( POS ('Wirth', 'Niklaus Wirth'));
(* Ergebnis ist die Zahl 9 *)
Ist der erste String nicht im zweiten enthalten, so ist das Funktionsergebnis die Zahl 0. Ebenfalls im report nicht vorhanden sind die folgenden Funktionen, die Umwandlungen zwischen Zahlen und Zeichenketten vornehmen.
PROGRAM KONVERTIERUNG (INPUT,OUTPUT);
VAR S: STRING;
R: REAL;
BEGIN
R:= RANDOM(0);
S:= STR(R) + '!' + STR (R : 14 : 8);
WRITELN(S);
R:= VAL(S);
WRITELN(R + 2.0);
END.
Die Funktion STR wandelt ihr Argument (eine ganze oder reelle Zahl) gemäß der Formatierungsregeln für reelle Zahlen bei der Prozedur WRITE in eine Zeichenkette um. Deshalb sind sowohl Exponential- als auch Festkommadarstellung möglich. Die umgekehrte Umwandlung ist mit der Funktion VAL möglich: Das Argument ist ein Stringausdruck, der eine Ziffernfolge enthalten muß, die der Syntax für reelle Zahlen entspricht. Der Wert dieser Ziffernfolge wird als Funktionsergebnis übergeben:
IF VAL ('2.0') = VAL ('000002.0000') THEN
WRITELN('Beide Zahlen sind gleich');
Natürlich können Sie diese Menge an Informationen nicht durch einmaliges Durchlesen verarbeiten. Jedoch gibt es sehr viele Anwendungen für Stringoperationen, bei denen sehr unterschiedliche Operationen benötigt werden. Schließlich besteht die Kunst des Programmierens auch in der Benutzung des richtigen Befehls zur rechten Zeit.