1:
2:
3:

i13;15;25;58;256;128;16;32
l15;564;67;31;46;54;
k88;546;54;5                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

procedure TForm1.Open1Click(Sender: TObject);
var
  F: TextFile;
  S: string;
begin
begin
  if OpenDialog1.Execute then          { Dialog zum Dateiöffnen anzeigen }
  begin
    AssignFile(F, OpenDialog1.FileName);   { Datei ausgewählt }
    Reset(F);
    Readln(F, S);                          { Erste Zeile der Datei lesen }
    Edit1.Text := S;                       { String in ein TEdit schreiben }
    CloseFile(F);

end;
end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

Function GetWordOfAnsiString(Text : string; WordPos : Word): string;
var
 p  : PChar;
begin
  p  := PChar(Text);
  repeat
    Dec(WordPos);
    while p^ <> #0 do
    begin
      if WordPos = 0 then
       Result := Result + p^;
      Inc(p);
    end;
    if WordPos = 0 then Exit;
    Inc(p);
  until p^ = #0;
end;                    

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

procedure explode(S: String; C: Char; List: TStrings);
Var
 I, J: Integer;
begin
 List.Clear;
 if S = '' then
  exit;
 J := 1;
 for I := 1 to length(S) do
  if S[I] = C then
  begin
   List.Add(Copy(S, J, I-J));
   J := I+1;
  end;
 List.Add(Copy(S, J, I-J));
end;

function implode(List: TStrings; C: Char): String;
Var
 I: Integer;
begin
 if List.Count = 0 then
 begin
  Result := '';
  exit;
 end else
  Result := List.Strings[0];
 For I := 1 to List.Count-1 do
  Result := Result + C + List.Strings[I];
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

Var
 List : TStringList;
 S : String;
 I : Integer;
begin
 S := 'Eintrag1;Eintrag2;Eintrag3';

 List := TStringList.Create;

 Explode(S,';', List); // String->List
 for I := 0 to List.Count-1 do
  // in List.Strings[I] sind die Einträge

 S := Implode(List, ';'); // List->String
 List.Free;
end;                    

1:

1;"Text mit "" im Text";"oder mit ; im Feld";123                    

1:
2:
3:
4:

1
Text mit " im Text
oder mit ; im Feld
123                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

var
  List: TStringList;
  s   : string;
  i   : integer;
begin
  List := TStringList.Create;

  s := 'test1;test2;test3;test4';
  List.Delimiter := ';';
  List.CommaText := s;

  for i := 0 to ( List.Count - 1 ) do begin
    // was auch immer
  end;

  List.Free;
end;                    

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

Function WortExtrahieren(Text: string; Wort: Word; Trennzeichen: Char): string;  
var  
 p  : PChar;  
begin  
  p  := PChar(Text);  
  repeat  
    Dec(Wort);  
    while p^ <> Trennzeichen do  
    begin  
      if Wort = 0 then  
       Result := Result + p^;  
      Inc(p);  
    end;  
    if Wort = 0 then Exit;  
    Inc(p);  
  until p^ = Trennzeichen;  
end; 

//Beispiel
str:= 'Hallo;Du;Da';
str2:= WortExtrahieren(str, 1, ';');
//Dann ist str2 = Hallo                    

1:

WortExtrahieren('a;b;c',3,';'); // Der zurückgegebene String ist 100 Zeichen gross!                    

1:

str:= 'Hallo;Du;Da;';                    

1:

until (p^ = Trennzeichen) or (not (ord(p^) in [1..255])); //<- das gleiche wie (p^ = #0)                    

1:
2:
3:

 p  : ^string;  
begin  
  p  := @Text;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

..
  private
    globalP: pchar;
..
var
  s: string;
  p: pchar;
begin
  s := 'test';
  p := pchar(s);
  globalP := p;
end;

procedure irgendwas;
begin
  showmessage(globalp); // hier wird noch test als resultat erscheinen.. wenn man glück hat. :) 
end;                    

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

Function WortExtrahieren(Text: string; Wort: Word; Trennzeichen: Char): string;
var
 p  : PChar;
begin
  p:= PChar(Text);
  repeat
    Dec(Wort);
    while p^ <> Trennzeichen do
    begin
      if Wort = 0 then
        Result := Result + p^;
      if p^ = #0 then
        Exit;
      Inc(p);
    end;
    if Wort = 0 then
      Exit;
    Inc(p);
  until (p^ = Trennzeichen);
  P:= nil;
end;                    

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

procedure TForm1.Button1Click(Sender: TObject);
var  s: string;
     p:pchar;
     pp, ps: pointer;
begin
  s:='bla';
  p:=pchar(s);
  ps:=@s;
  pp:=@p;
  if ps <> pp then showmessage('uneven');
end;                    

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

var
  s: string;
  p: pchar;
begin
  s := 'test';
  p := pchar(s);

  if pointer(p) = pointer(s) then showmessage('gleich');
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

Var
 S : String;
 P : PChar;
begin
 S := 'abcdefg'; // hardcoded
 P := PChar(S);  // hier wird eine Kopie erstellt
 S[2] := 'B';
 ShowMessage(P); // abcdefg

 S := 'abcd';    // hardcoded
 S := S + 'efg'; // hier wird eine Kopie des Strings erstellt (mit GetMem)
 P := PChar(S);  // hier gibt's keine erneute Kopie mehr
 S[2] := 'B';
 ShowMessage(P); // aBcdefg
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:

var
  p1,
  p2,
  p3,
  p4: pointer;
  pc: pchar;
  s : string;
  c1,
  c2: char;
begin
{
pc ist unsere variable, die den zeiger kennt.

daß pc vom typen pchar also der enthaltene zeiger auf einen char zeigt, ist dabei unerheblich.

@pc gibt den offset auf die variable p, also unseren eigentlichen pointer auf pc.
pointer(pc) macht nen typcast in diesem fall und gibt uns den zeiger auf den char zurück.
also gilt pchar(pointer(pc)) = pc;
}
  s := 'TEST';

  pc := pchar(s);

  // p1 = p2 -> p1^ = p2^ = s[1];
  p1 := pointer(s); // zeiger von s -> char(p1^) = 'T'
  p2 := pointer(pc); // zeiger von pc -> char(p2^) = 'T'

  p3 := @s; // offset
  if p1 = pointer(p3^) then showmessage('gleich');
  p4 := @pc; // offset
  if p2 = pointer(p4^) then showmessage('gleich');

  // hier der beweis, daß der wert in der variable verändert wird,
  // aber der offset von pc nicht
  inc(pc);
  if @pc = p4 then showmessage('gleich');

  // ergo muß der compiler nix machen außer pc wie eine normale variable
  // z.B. integer, string etc. zu behandeln
end;                    

1:
2:

S := S + #0;
p := @S[1];                    

1:
2:

S := 'Hallo '+A+' und '+B+' '+IntToStr(I);
S := Format('Hallo %s und %s %d',[A,B,I]);                    

1:
2:
3:

Zahl1 := StrToInt (copy (zeile,1,10));
Zahl2 := StrToInt (copy (zeile,11,10));
Zahl3 := StrToInt (copy (zeile,21,10));                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

SemikolonPos := pos (';',Zeile);
HilfStr := copy (zeile,1,SemikolonPos-1); // String bis zum ersten Semikolon umkopieren
Zahl1 := StrToInt (copy (HilfStr,1,10));
delete (zeile,1,SemikolonPos);            // bereits umgewandelten TeilString entfernen.

SemikolonPos := pos (';',Zeile);
HilfStr := copy (zeile,1,SemikolonPos-1); 
// String bis zum jetzt ersten Semikolon umkopieren
Zahl2 := StrToInt (copy (HilfStr,1,10));
delete (zeile,1,SemikolonPos);            // bereits umgewandelten TeilString entfernen.

SemikolonPos := pos (';',Zeile);
HilfStr := copy (zeile,1,SemikolonPos-1); 
// String bis zum jetzt ersten Semikolon umkopieren
Zahl3 := StrToInt (copy (HilfStr,1,10));
delete (zeile,1,SemikolonPos);            // bereits umgewandelten TeilString entfernen.                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

Var
 a, b, c : Integer
begin
 AssignFile(F, 'test.txt');
 reset(F);
 while not eof(F) do
 begin
  Read(F, a, b, c);
  // ...
 end;
 CloseFile(F);
end;