Diese Funktion schneller machen?

[ibp]

Zitat:

Zitat von Robert Marquardt

Wie waere es denn mit
Result := StringReplace(S, Ch + Ch, Ch, [rfReplaceAll]);
Dann muss nur noch auf ein Ch am Ende getestet werden.

Zitat:

Zitat von Pseudemys Nelsoni

...es sollten keine funktionen aus der VCL verwendet werden.

[Chewie]

Zitat:

Zitat von ibp

Zitat:

Zitat von Robert Marquardt

Wie waere es denn mit
Result := StringReplace(S, Ch + Ch, Ch, [rfReplaceAll]);
Dann muss nur noch auf ein Ch am Ende getestet werden.

Zitat:

Zitat von Pseudemys Nelsoni

...es sollten keine funktionen aus der VCL verwendet werden.

StringReplace ist auch nicht Teil der VCL, sondern der RTL ;) .

[ibp]

ok ok :duck: geb mich geschlagen, bitte nicht mit schneebällen werfen :freak:

[sECuRE]

Hi,

spaßeshalber hab ich mal 'nen vergleich zwischen StringReplace und Nelsonis Variante gemacht, raus kam bei StringReplace 1297 Ticks und bei der anderen lediglich 62 Ticks (bei jeweils 100000x aufrufen). Pos + StringReplace ist also definitiv die langsamere Methode ;)

cu

[Pseudemys Nelsoni]

@mütze: das ganze sollte wenn überhaupt nur die funktionen aus der Unit "System" bzw "Windows" verwenden

@jim: der + operator ist aber (unbedeutend?) schneller als inc().

@Robert: dann müsste ich die unit SysUtils einbinden.

Zitat:

statt immer s[i] und result[len] zu machen könntest du auch einen Pointer (PChar) verwenden, der immer erhöht wird.[/delphi]

das interessiert mich ^^, hast du ein beispiel dafür? ich arbeite kaum mit pchars

[jim_raynor]

Zitat:

Zitat von Pseudemys Nelsoni

Zitat:

statt immer s[i] und result[len] zu machen könntest du auch einen Pointer (PChar) verwenden, der immer erhöht wird.[/delphi]

das interessiert mich ^^, hast du ein beispiel dafür? ich arbeite kaum mit pchars

Kein Beispiel sondern deine Funktion direkt umgeschrieben:

Delphi-Quellcode:

function fmtstr(const s: string; const c: char): string;
var
  i, len  : integer;
  ResLen  : Integer;
  b       : boolean;
  Start   : Integer;
  resPtr  : PChar;
  sPtr    : PChar;

  endsPtr : Pchar;
begin
  if s <> '' then
  begin
    b := false;

    Len:=Length(s);
    setlength(result, len);
    Start:=1;
    sPtr:=Addr(s[1]);
    resPtr:=Addr(result[1]);
    endsPtr:=Addr(s[length(s)]);

    while (sPtr^=c) and (sPtr<endsPtr) do
    begin
      inc(Start);
      inc(sPtr);
    end;

    ResLen:=0;

    for i := Start to Len do
    begin
      if (sPtr^ <> c) or (not b) then
      begin
        resPtr^ := sPtr^;
        inc(resPtr);
        inc(ResLen);
      end;

      b:=sPtr^=c;

      inc(sPtr);
    end;
    if (resPtr-1)^ = c then
      setlength(result, reslen-1)
    else
      setlength(result, reslen);
  end;
end;

Sieht zwar Länger aus, denke aber, dass es so schneller ist, da die ganzen Indexzugriffe entfallen. Ist natürlich bissle kryptisch, wenn Fragen sind, dann frag.

[Nothine]

Zitat:

Zitat von Pseudemys Nelsoni

@jim: der + operator ist aber (unbedeutend?) schneller als inc().

wie soll das gehen wenn beide anweisungen den selben maschinencode erzeugen? :gruebel:

[edit]

Zitat:

Zitat von Meine OH

...
X wird um 1 inkrementiert oder um N, wenn N angegeben ist. Das bedeutet, Inc(X) entspricht der
Anweisung X := X + 1, und Inc(X, N) ist mit der Anweisung X := X + N identisch. Inc generiert jedoch hochoptimierten Maschinencode und ist besonders für Schleifen geeignet.
...

[jim_raynor]

Zitat:

Zitat von Nothine

wie soll das gehen wenn beide anweisungen den selben maschinencode erzeugen? :gruebel:

Zitat:

Zitat von Meine OH

... Inc generiert jedoch hochoptimierten Maschinencode und ist besonders für Schleifen geeignet....

Sie generieren eben nicht identischen Maschienencode. Die OH sagt doch alles.

[Pseudemys Nelsoni]

danke jim, ich testes gleich mal :)

btw: in der OH steht irgendwo "Tipp: der + operator ist schneller als inc"

[Robert_G]

OT:

Zitat:

Zitat von Pseudemys Nelsoni

danke jim, ich testes gleich mal :)

btw: in der OH steht irgendwo "Tipp: der + operator ist schneller als inc"

Da steht höchstens, dass + schneller als concat ist. ;) Ich bezweifle einen Unterschied zwischen + und inc() im Kompilat.