In komplexen Ausdrücken wird die Reihenfolge, in der Operationen ausgeführt wer-den, durch die Rangfolge der Operatoren festgelegt.
Ein Operator mit einer höheren Rangfolge wird vor einem Operator mit einer niedri-geren Rangfolge ausgewertet. Operatoren mit gleicher Rangfolge werden von links nach rechts ausgewertet. Aus diesem Grund multipliziert der folgende Ausdruck zu-nächst Y mit Z und addiert dann X zum Resultat der Multiplikation:
X + Y * Z
Die Operation * (Multiplikation) wird zuerst ausgeführt, weil dieser Operator eine höhere Rangfolge als der Operator + hat. Im folgenden Ausdruck wird aber zunächst Y von X subtrahiert und danach Z zum Resultat addiert:
X - Y + Z
Die Operatoren – und + weisen dieselbe Rangfolge auf. Aus diesem Grund wird die Operation auf der linken Seite zuerst ausgeführt.
Mit Hilfe von runden Klammern lassen sich die Rangfolgeregeln außer Kraft setzen.
Ein Ausdruck in runden Klammern wird immer zuerst ausgewertet und danach wie ein einzelner Operand behandelt. Der folgende Ausdruck multipliziert Z mit der Summe von X und Y:
(X + Y) * Z
Tabelle 4.11 Wertigkeit der Operatoren
Operator Rangfolge
@, not Erste (höchste)
*, /, div, mod, and, shl, shr, as Zweite
+, , or, xor Dritte
=, <>, <, >, <=, >=, in, is Vierte (niedrigste)
Manchmal sind Klammern in Situationen erforderlich, die dies auf den ersten Blick nicht vermuten lassen. Sehen Sie sich den folgenden Ausdruck an:
X = Y or X = Z
Die beabsichtigte Interpretation lautet offensichtlich (X = Y) or (X = Z)
Wenn keine Klammern gesetzt werden, hält sich der Compiler an die Regeln für die Rangfolge der Operatoren und interpretiert den Ausdruck folgendermaßen:
(X = (Y or X)) = Z
Wenn Z nicht vom Typ Boolean ist, führt dies zu einem Compilierungsfehler.
Runde Klammern erleichtern zwar häufig das Schreiben und Lesen des Quelltextes, sind aber strenggenommen überflüssig. Das erste der obigen Beispiele könnte auch folgendermaßen formuliert werden:
X + (Y * Z)
Hier sind die Klammern (für den Compiler) unnötig, erleichtern aber dem Program-mierer und dem Leser die Interpretation, weil die Regeln für die Operatorrangfolge nicht berücksichtigt werden müssen.
Funktionsaufrufe
Funktionsaufrufe sind Ausdrücke, da sie einen Wert zurückliefern. Wenn Sie bei-spielsweise eine Funktion mit dem Namen Calc definiert haben, die zwei Integer-Ar-gumente übernimmt und einen Integer-Wert zurückgibt, stellt der Funktionsaufruf Calc(24,47) einen Integer-Ausdruck dar. Sind I und J Integer-Variablen, ist
I + Calc(J,8) ebenfalls ein Integer-Ausdruck. Hier einige Beispiele für Funktionsauf-rufe:
Sum(A, 63) Maximum(147, J) Sin(X + Y) Eof(F)
Volumen(Radius, Höhe) GetValue
TSomeObject.SomeMethod(I,J);
Ausführliche Informationen über Funktionen finden Sie in Kapitel 6, »Prozeduren und Funktionen«.
Mengenkonstruktoren
Ein Mengenkonstruktor bezeichnet einen Wert eines Mengentyps, z.B.
[5, 6, 7, 8]
Dieser Mengenkonstruktur bezeichnet eine Menge mit den Ziffern 5, 6, 7 und 8. Die-selbe Menge könnte auch mit dem folgenden Mengenkonstruktor bezeichnet wer-den:
[ 5..8 ]
Die Syntax für einen Mengenkonstruktor lautet:
[ Element1, ..., Elementn ]
Hierbei kann Element ein Ausdruck sein, der einen Ordinalwert des Basistyps der Menge bezeichnet, oder ein Paar solcher Ausdrücke, die durch zwei Punkte (..) mit-einander verbunden sind. Hat ein Element die Form x..y, bezeichnet es alle Ordinal-werte von x bis y. Ist x jedoch größer als y, repräsentiert x..y keine Elemente, und [x..y]
steht für eine leere Menge. Der Mengenkonstruktor [ ] bezeichnet die leere Menge, während [x] eine Menge repräsentiert, deren einiges Element der Wert x ist.
Hier einige Beispiele für Mengenkonstruktoren:
[rot, grün, Farbe]
[1, 5, 10..K mod 12, 23]
['A'..'Z', 'a'..'z', Chr(Ziffer + 48)]
Ausführliche Informationen über Mengen finden Sie unter »Mengentypen« auf Seite 5-17.
Indizes
Strings, Arrays, Array-Eigenschaften und Zeiger auf Strings oder Arrays können in-diziert werden. Beispielswiese liefert der Ausdruck Dateiname[3] für die String-Varia-ble Dateiname den dritten Buchstaben in dem durch Dateiname bezeichneten String.
Dagegen gibt Dateiname[I + 1] das Zeichen zurück, das unmittelbar auf das mit I indi-zierte Zeichen folgt. Ausführliche Informationen über Strings finden Sie unter
»String-Typen« auf Seite 5-10. Einzelheiten zu Arrays und Array-Eigenschaften fin-den Sie unter »Array-Typen« auf Seite 5-18 und unter »Array-Eigenschaften« auf Seite 7-19.
Typumwandlungen
In bestimmten Situationen ist es erforderlich, den Typ eines Ausdrucks zu ändern.
Durch eine Typumwandlung kann einem Ausdruck vorübergehend ein anderer Typ zugeordnet werden. Beispielsweise konvertiert die Anweisung Integer ('A') den Buchstaben A in einen Integer.
Die Syntax für eine Typumwandlung lautet:
Typbezeichner(Ausdruck)
Handelt es sich bei dem Ausdruck um eine Variable, spricht man von einer Variablen-umwandlung, andernfalls von einer Wertumwandlung. Obwohl die Syntax einer Wert-umwandlung mit derjenigen einer VariablenWert-umwandlung identisch ist, gelten für die beiden Umwandlungsarten unterschiedliche Regeln.
Wertumwandlungen
Bei einer Wertumwandlung müssen sowohl der Typbezeichner als auch der umzu-wandelnde Ausdruck entweder ein ordinaler Typ oder ein Zeigertyp sein. Hier eini-ge Beispiele für Wertumwandluneini-gen:
Integer('A') Char(48) Boolean(0) Color(2) Longint(@Buffer)
Der resultierende Wert ergibt sich aus der Umwandlung des Ausdrucks in Klam-mern. Dabei wird der ursprüngliche Wert möglicherweise abgeschnitten oder erwei-tert, wenn die Größe des neuen Typs sich vom Typ des Ausdrucks unterscheidet. Das Vorzeichen des Ausdrucks bleibt aber in jedem Fall erhalten.
Die folgende Anweisung weist der Variablen I den Wert von Integer ('A') zu (also 65):
I := Integer('A');
Auf eine Wertumwandlung dürfen keine Qualifizierer folgen. Außerdem sind Wert-umwandlungen nur auf der rechten Seite einer Zuweisung erlaubt.
Variablenumwandlungen
Variablen können in jeden beliebigen Typ umgewandelt werden. Dabei muß aller-dings die Größe gleich bleiben, und Integer-Typen dürfen nicht mit Real-Typen ver-mischt werden (verwenden Sie zur Umwandlung numerischer Typen Standardfunk-tionen wie Int und Trunc). Hier einige Beispiele für Variablenumwandlungen:
Char(I) Boolean(Count)
TSomeDefinedType(MyVariable)
Variablenumwandlungen sind auf beiden Seiten einer Zuweisung erlaubt:
var MyChar: char;
ƒ
Shortint(MyChar) := 122;
Bei dieser Umwandlung wird MyChar das Zeichen z (ASCII 122) zugewiesen.
Variablen können in prozedurale Typen umgewandelt werden. Mit den Deklaratio-nen
type Func = function(X: Integer): Integer;
var F: Func;
P: Pointer;
N: Integer;
sind z.B. folgende Zuweisungen möglich:
F := Func(P); { Prozeduralen Wert in P an F zuweisen } Func(P) := F; { Prozeduralen Wert in F an P zuweisen }
@F := P; { Zeigerwert in P an F zuweisen } P := @F; { Zeigerwert in F an P zuweisen } N := F(N); { Funktion über F aufrufen } N := Func(P)(N); { Funktion über P aufrufen}
Wie das folgende Beispiel zeigt, dürfen auf Variablenumwandlungen auch Qualifi-zierer folgen:
type
TByteRec = record Lo, Hi: Byte;
end;
TWordRec = record Low, High: Word;
end;
PByte = ^Byte;
var B: Byte;
W: Word;
L: Longint;
P: Pointer;
begin
W := $1234;
B := TByteRec(W).Lo;
TByteRec(W).Hi := 0;
L := $01234567;
W := TWordRec(L).Low;
B := TByteRec(TWordRec(L).Low).Hi;
B := PByte(L)^;
end;
In diesem Beispiel wird mit TByteRec auf das niedrigst- und höchstwertige Byte eines Word zugegriffen. Über TWordRec erfolgt ein Zugriff auf das niedrigst- und höchst-wertige Word eines Longint. Zu diesem Zweck könnten auch die vordefinierten Funktionen Lo und Hi verwendet werden. Die Variablenumwandlung bietet aber den Vorteil, daß sie auf der linken Seite einer Zuweisung stehen kann.
Informationen über die Typumwandlung von Zeigern finden Sie unter »Zeiger und Zeigertypen« auf Seite 5-27. Ausführliche Informationen zur Umwandlung von Klas-sen- und Schnittstellentypen finden Sie unter »Der Operator as« auf Seite 7-25 und unter »Schnittstellenumwandlungen« auf Seite 10.