Delemiter > Char

[EWeiss]

Ich möchte auf einen Delemiter hin parsen der mehr als 1 Char enthält.

Delphi-Quellcode:

function tcsstr(str, Pattern: PAnsiChar): PAnsiChar;
var
  mi: Integer;
begin
  mi := -1;

  while Pattern[mi] <> Pattern do
  begin
    if str[mi] = '0' then
    begin
      result := nil;
      exit;
    end;

    if(str[mi] <> Pattern[mi]) then
    begin
      Inc(str, 1);
      mi := -1;
    end;
    inc(mi);
  end;
  result := str;
end;

Pattern ist ',"'
Der String wird solange um 1 Char(zeichen) gelöscht bis Pattern[mi] = Pattern ist.

Nur das tritt nie ein.

Wo ist der Denkfehler?

In C++ ist das einfach aber in Delphi will es irgendwie nicht.

Code:

WCHAR* tcsstr(WCHAR* String, WCHAR* Pattern) {
    int mi = -1;
    while(Pattern[++mi]) {
        if(String[mi] == 0) 
            return 0;
        if(String[mi] != Pattern[mi]) {
            String++;
            mi = -1;
        }
    }
    return String;
}

gruss

[Fritzew]

Das begint schon mit der signatur
dein delphi code untersucht pansichar = 1 byte
Der c++ code wchars = 2 byte
Dann beginnt der delphi teil mit einem index von-1 ???
Mi muss im delphi teil 0 sein
du weist was ++mi macht (c++)?

Sorry aber das passt nicht zusammen

[EWeiss]

Zitat:

Sorry aber das passt nicht zusammen

Deshalb frage ich ja

Zitat:

dein delphi code untersucht pansichar = 1 Byte

Habe ich mir gedacht aber wie kann man es ändern?

Zitat:

Dann beginnt der delphi teil mit einem index von-1 ???

Das ist korrekt wird ja unten um 1 incrementiert.

Zitat:

du weist was ++mi macht (c++)?

Ja inc(mi)

gruss

[Fritzew]

Na ja auch pwidechar benutzen, un im delpdicode immer 0 anstatt -1 für mi

[EWeiss]

Zitat von Fritzew:

Na ja auch pwidechar benutzen, un im delpdicode immer 0 anstatt -1 für mi

sorry aber ich benötige bedingt durch den Text der geliefert wird PAnsiChar nicht PWideChar.
Sonst habe ich Kauderwelsch.
Ich benötige den Text in Klarschrift.

und -1 ist korrekt. Weil 0 bei mir gleich NULL(#0) darstellt.


OK.. Hat sich erledigt nach abändern einer zeile.

while mi <> 2 do

gruss

[Fritzew]

Emil,
Was ist ein pansichar? Ein pointer auf ein array
Wo zeigt dann -1 hin? Pattern[-1] kann niemals korrekt sein!
Und wenn du pansichar brauchst warum zeigst du dann code der
pwchar benutzt?

[Dalai]

Zitat von EWeiss:

und -1 ist korrekt.

Kann es nicht sein, weil es Pattern[-1] nicht gibt. Das innerhalb der Schleife befindliche Inc(mi) hilft da nicht. In C/C++ gibt es nun mal einen Unterschied zwischen ++mi und mi++ (ich denke, das dürfte dir bekannt sein) - deswegen funktioniert dort sowas wie

Code:

int mi = -1;
while(Pattern[++mi]) {

Der erste Schleifendurchlauf ist Pattern[0] - im Gegensatz zu deinem Delphi-Code

Delphi-Quellcode:

mi := -1;
while Pattern[mi] <> Pattern do

, wo es Pattern[-1] ist. Hättest du in deinem C++-Code Pattern[mi++] geschrieben, hätte es dort genausowenig funktioniert.

Grüße
Dalai

[EWeiss]

Zitat:

Wo zeigt dann -1 hin? Pattern[-1] kann niemals korrekt sein!

str[mi] wenn -1 dann ist das Ergebnis "#0" das ist korrekt.

dann wird
str[mi] <> Pattern[mi] verglichen beides ist "#0"

anschließend wird mi incrementiert also 0
dann ist mein erstes zeichen str[mi] wenn 0 '"' was auch korrekt ist.

Ist nun das erste zeichen des Pattern erreicht in dem Fall ',' wird mi hochgezählt auf 1
Ist das zweite zeichen erreicht in dem Fall '"' wird mi hochgezählt auf 2

Danach habe ich exakt den String den ich beim parsen erreichen will.

Zitat:

',"id":19995....

Also ',"' war mein Pattern.

gruss

[EWeiss]

Zitat:

wo es Pattern[-1] ist. Hättest du in deinem C++-Code Pattern[mi++] geschrieben, hätte es dort genausowenig funktioniert.

c++

Code:

als Präfix-Operator:
++i;
int x, y;
x = 3;
y = ++x;
// y = 4 und x = 4

als Postfix-Operator:
i++;
int x, y;
x = 3;
y = x++;
// y = 3 und x = 4

Delphi

Delphi-Quellcode:

inc(i); oder i:= i + 1;
var x, y: Integer;
x:= 3;
inc(x);
y:= x;
// y = 4 und x = 4

inc(i); oder i:= i + 1;
var x, y: Integer;
x:= 3;
y:= x;
inc(x);
// y = 3 und x = 4

gruss

[Zacherl]

Bezüglich des Operators ansich hast du Recht:

• ++i ist der Pre-increment-Operator, der zuerst inkrementiert, bevor er die Variable verwendet. Wenn i = 0 , dann steht nach x = ++i die Zahl 1 in x .
• i++ ist der Post-increment-Operator, der erst inkrementiert, nachdem er die Variable verwendet. Wenn i = 0 , dann steht nach x = i++ die Zahl 0 in x .

In beiden Fällen ist i nach der Ausführung 1 .

Dein Originalcode hat dennoch auf Pattern[-1] zugegriffen, was im Zweifelsfalle eine Zugriffsverletzung darstellt.

1 zu 1 übersetzt sollte die Funktion ca. so aussehen (mit der PWideChar zu PAnsiChar Änderung):

Delphi-Quellcode:

function tcsstr(Str, Pattern: PAnsiChar): PAnsiChar;
var
  I: Integer;
begin
  Assert(Assigned(Str) and Assigned(Pattern));
  I := 0;
  while (Pattern[I] <> #0) do
  begin
    if (Str[I] = #0) then
    begin
      Exit(nil);
    end;
    if (Str[I] <> Pattern[I]) then
    begin
      Inc(Str);
      I := -1;
    end;
    Inc(I);
  end;
  Result := Str;
end;