Code optimieren

[klebe7]

Hallo,

Ich bin Anfänger in Delphi und brauche mal Hilfe.
Könnt ihr mir Tipps geben, wie ich folgenden Code beschleunigen/optimieren kann, da er einfach zu langsam ist, wenn ich ihn oft aufrufe.

Delphi-Quellcode:

function RemoveChars(const ASource, AChars: string): string;
var
  i, j: Integer;
  bFlag: Boolean;
begin
  Result := '';
  for i := 1 to Length(ASource) do
  begin
    bFlag := False;
    for j := 1 to Length(AChars) do
      if ASource[i] = AChars[j] then
      begin
        bFlag := True;
        Break;
      end;
    if not bFlag then
      Result := Result + ASource[i];
  end;
end;

[Klaus01]

Guten Abend,

vielleicht geht es so besser?

Delphi-Quellcode:

for i:=1 to length(AChars) do
  begin
    Source:= StringReplace(Source,AChars[i],'',rfReplaceAll);
  end;

Aber ich wüsste jetzt nicht wo in Deinem code eine Bremse
sein sollte.

Grüße
Klaus

[DeddyH]

Mal aus der hohlen Hand:

Delphi-Quellcode:

type TChars = set of Char;

function RemoveChars(const aString: string; Chars: TChars): string;
var i, j: Integer;
begin
  SetLength(Result,Length(aString));
  j := 1;
  for i := 1 to Length(aString) do
    begin
      if not(aString[i] in Chars) then
        begin
          Result[j] := aString[i];
          Inc(j);
        end;
    end;
  SetLength(Result,Pred(j));
end;

[alzaimar]

Hier eine Version, die nochmal 50% rausholt (die Zeit also quasi halbiert)

Delphi-Quellcode:

function PRemoveChars(const aString: string; Chars: TChars): string;
var
  pSource, pResult, pEnd: PChar;

begin
  SetLength(Result, Length(aString));
  pSource := @aString[1];
  pResult := @Result[1];
  pEnd := pSource + Length(aString) - 1;
  while pSource <= pEnd do begin
    if not (pSource^ in Chars) then begin
      pResult^ := pSource^;
      inc(pResult);
    end;
    inc(pSource);
  end;
  SetLength(Result, integer(pResult) - integer(@Result[1]));
end;

[DeddyH]

Das dürfte aber Probleme geben, wenn man einen Leerstring übergibt.

[klebe7]

Vielen Dank an alle. Ich probiere es aus.

[alzaimar]

Zitat:

Zitat von DeddyH

Das dürfte aber Probleme geben, wenn man einen Leerstring übergibt.

Dann eben eine Abfrage einbauen, alter Pedant :zwinker:

[DeddyH]

Mach ich mal:

Delphi-Quellcode:

function PRemoveChars(const aString: string; Chars: TChars): string;
var
  pSource, pResult, pEnd: PChar;

begin
  SetLength(Result, Length(aString));
  if Length(aString) > 0 then
    begin
      pSource := @aString[1];
      pResult := @Result[1];
      pEnd := pSource + Length(aString) - 1;
      while pSource <= pEnd do begin
        if not (pSource^ in Chars) then begin
          pResult^ := pSource^;
          inc(pResult);
        end;
        inc(pSource);
      end;
      SetLength(Result, integer(pResult) - integer(@Result[1]));
    end;
end;

[Puhbaehr]

In meiner fast 10 jährigen Erfahrung mit Delphi bin ich eben das erste mal über eine Routine gestolpert die mir bisher unbekannt war.

Zitat:

Zitat von DeddyH

Mal aus der hohlen Hand:

Delphi-Quellcode:

type TChars = set of Char;

function RemoveChars(const aString: string; Chars: TChars): string;
var i, j: Integer;
begin
  //...
  SetLength(Result,Pred(j));
end;

Pred (x: Integer);
Ist die Routine Pred (x) so viel schneller als x - 1, dass sich die Verwendung lohnt?

Irgendwo hier im Forum las ich einmal, dass die Verwendung von inc/dec (x) sogar langsamer sei als x := x +/- 1;
Aus diesem Grund frage ich.

Gruß, Robert

[Luckie]

Zitat:

Zitat von Puhbaehr

Irgendwo hier im Forum las ich einmal, dass die Verwendung von inc/dec (x) sogar langsamer sei als x := x +/- 1;
Aus diesem Grund frage ich.

Kann ich mir nicht vorstellen, da bei aktuellen Delphi Versionen identischer ASM Code generiert wird.