1:
2:
3:
4:
5:

PInfo := Pointer(Integer(PMessage) + SizeOf(Header))

oder

PInfo := PInfo(Integer(PMessage) + SizeOf(Header))					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

Die relationalen Operatoren <, >, <= und >= können Operanden vom Typ PChar haben (siehe den
Abschnitt Relationale Operatoren). Bei den folgenden Operatoren können die Operanden auch Zeiger sein.
Ausführlichere Informationen über Zeiger finden Sie im Abschnitt Zeiger und Zeigertypen.

Operator  Operation  Operandtyp  Ergebnistyp  Beispiel
+  Zeiger-Addition  Zeichenzeiger, Integer   Zeichenzeiger  P + I 
-  Zeiger-Subtraktion  Zeichenzeiger, Integer  Zeichenzeiger, Integer  P - Q 
^  Zeiger-Dereferenzierung  Zeiger   Basistyp von Zeiger  P^
=  Gleichheit   Zeiger   Boolean  P = Q 
<>  Ungleichheit  Zeiger  Boolean   P <> Q 
Der Operator ^ dereferenziert einen Zeiger. Sein Operand kann ein Zeiger auf einen beliebigen Typ mit
Ausnahme des generischen Typs Pointer sein, der vor der Dereferenzierung umgewandelt werden muß.
P = Q ist nur dann True, wenn P und Q auf dieselbe Adresse zeigen.
Mit den Operatoren + und – kann der Offset eines Zeichenzeigers erhöht oder erniedrigt werden. Mit dem
Operator – können Sie außerdem den Unterschied zwischen den Offsets zweier Zeichenzeiger berechnen. Für
Zeiger-Operatoren gelten die folgenden Regeln:

Wenn I vom Typ Integer und P ein Zeichenzeiger ist, addiert P + I den Wert I zu der von P angegebenen
Adresse. Es wird also ein Zeiger auf die Adresse zurückgegeben, die I Zeichen hinter P liegt. (Der
Ausdruck I + P entspricht P + I.) P – I subtrahiert I von der Adresse, die von P angegeben wird. Das
Ergebnis ist ein Zeiger auf die Adresse, die I Zeichen vor P liegt.
  Wenn P und Q Zeichenzeiger sind, berechnet P – Q die Differenz zwischen der von P angegebenen
(höheren) und der von Q angegebenen (niedrigeren) Adresse. Es wird also ein Integer-Wert für die Anzahl
der Zeichen zwischen P und Q zurückgegeben. Das Ergebnis von P + Q ist nicht definiert.					

1:
2:
3:
4:
5:
6:
7:

var
  S  : String;
  ps : Pointer;

begin
  PS := @S;
  PS := PS+1;					

1:

PS := Pointer(Integer(PS) + 1);					

1:
2:
3:
4:
5:
6:
7:
8:
9:

var
  S  : String;
  ps : PChar;
begin
  S := 'Hallo Welt';
  PS := @S[1];
  PS := PS + 1;
  ShowMessage(PS^);
end;					

1:

PInfo := PInfo(UIntPtr(PMessage) + SizeOf(Header))					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

var
  IntArray: array [0..3] of Integer = (0, 1, 2, 3);
  P: PInteger;

begin
  // lasse P auf Element 0 zeigen
  P := @IntArray[0];
  // lasse P auf Element 2 zeigen
  P := P + 2; // Compiler meckert! "Operator not applicable to this operand type"
  Inc(P, 2);  // funktioniert! Bewegt Zeiger in Abhängigkeit der Größe des Typs, hier also 2 Integer = 8 Byte weiter
end;


{$POINTERMATH ON}

begin
  // lasse P auf Element 0 zeigen
  P := @IntArray[0];
  // lasse P auf Element 2 zeigen
  P := P + 2;  // funktioniert! Entspricht exakt "Inc(P, 2)"
  // dank POINTERMATH können Pointer als offene Arrays benutzt werden!
  P[-2] := 10; // funktioniert! IntArray[0] ist jetzt = 10
end;