StringList oder dynamisches Array.

[Luckie]

Da wäre jetzt dein Code interessant wie du befüllst und wie du die Zeit misst.

[Iwo Asnet]

Delphi-Quellcode:

program TestStringLists;

{$APPTYPE CONSOLE}

uses
  Windows, Classes, SysUtils;
Const
  R = 1000;

Var
  A : Array [0..10000] Of String;
  S : TStringList;
  
  Procedure ArrayProc;
  Var
    T : Cardinal;
    i : Integer;
    Procedure AppendProc;
    Var i : Integer;
    Begin
      for I := 0 to High(a) do A[i] := '123123123123';
    End;

    Procedure FetchProc;
    Var i : Integer; s: String;
    Begin
      for I := 0 to High(a) do s := A[i];
      if S='123' then A[0] := '';
    End;

    Procedure InsertProc;
    Var i : Integer;
    Begin
      for I := 0 to High(A) do
        Move(A[0], A[1], High(A)*SizeOf(A[0]));
    End;

    Procedure DeleteProc;
    Var i : Integer;
    Begin
      for I := 0 to High(A) do
        Move(A[1], A[0], High(A)*SizeOf(A[0]));
    End;
  Begin
    T := GetTickCount;
    For i:=1 to R do AppendProc;
    Writeln('Array - Add : ',GetTickcount-t);
    T := GetTickCount;
    For i:=1 to R do FetchProc;
    Writeln('Array - Fetch : ',GetTickcount-t);
    T := GetTickCount;
    For i:=1 to R div 100 do Begin InsertProc; DeleteProc; End;
    Writeln('Array - Ins/Del : ',GetTickcount-t);
  End;
  Procedure StringListProc;
  Var
    T : Cardinal;
    i : Integer;
    Procedure AppendProc;
    Var i : Integer;
    Begin
      for I := 0 to High(a) do S.Add('123123123123');
    End;

    Procedure FetchProc;
    Var i : Integer; x: String;
    Begin
      for I := 0 to High(a) do x := S[i];
      if x='123' then S[0] := '';
    End;

    Procedure InsertProc;
    Var i : Integer;
    Begin
      for i := 0 to High(A) do begin
        S.Insert(0,'1^23123123');
        s.Delete(0);
      end;
    End;

    Procedure DeleteProc;
    Var i : Integer;
    Begin
      for i := 0 to High(A) do
        S.Delete(0);
    End;
  Begin
    s:= TStringlist.Create;
    T := GetTickCount;
    For i:=1 to R do AppendProc;
    Writeln('StrLst - Add : ',GetTickcount-t);

    T := GetTickCount;
    For i:=1 to R do FetchProc;
    Writeln('StrLst - Fetch : ',GetTickcount-t);
    s.clear;
    AppendProc; // damit die Stringlist auch 10000 elemente zum Testen hat
    T := GetTickCount;
    For i:=1 to R div 100 do InsertProc;
    Writeln('StrLst - In/Del : ',GetTickcount-t);
   s.free;
 End;
begin
  ArrayProc;
  StringListProc;
  ReadLn;
end.

[Luckie]

Also GetTickCount ist dazu schon mal ungeeignet. Wenn dann sollte man mit GetThreadTimes, um genauere Werte zu erhalten.

[jaenicke]

Und davon ganz abgesehen ist das hier kein dynamisches Array. Ein festes Array zu nehmen um festzustellen wie sich ein dynamisches Array zu einer TStringList verhält, ist schon reichlich seltsam... :roll:
Denn die Operationen, die dabei eigentlich interessieren, kann man so ja gar nicht testen...

[Iwo Asnet]

@Luckie: Ob nun GetTickCount oder etwas anderes ist bei 500-700ms egal, oder etwa nicht?
@Jaenicke: Ob nun Array oder dynamisches Array ist eigentlich auch egal, auch wenn ich deine Ansicht im Prinzip teile. Ein dynamisches Array wird bei Zugriff über eine Dereferenzierung vermutlich etwas langsamer werden.

Aber wer mag, kann ja ein dynamisches Array einbauen und einen ultragenauen Zeitmesser obendrauf. Ob das Ergebnis -speziell durch eine Atomuhr- nun anders ausfällt, wage ich zwar zu bezweifeln, aber ich lasse mich gern eines besseren belehren. Hier wird der CPU-Cache eine viel größere Rolle spielen.

Interessant für mich ist der Overhead bei den Insert/Delete-Operationen, die man vielleicht optimieren kann. Wenn man will.

[mkinzler]

Zitat:

@Jaenicke: Ob nun Array oder dynamisches Array ist eigentlich auch egal, auch wenn ich deine Ansicht im Prinzip teile. Ein dynamisches Array wird bei Zugriff über eine Dereferenzierung vermutlich etwas langsamer werden.

Aber nur wenn man den dynamischen Array anfänglich auzch auf einen sehr großen Wert dimensioniert. Im Normalfall macht man das ja nicht ( sonst bräucht man keinen dynamischen Array, dessen Vorteil es ja ist, dass die Größe änderbar ist.)