dynamische Arrays vergrößern

[SimStar001]

Zitat von alzaimar:

Zitat von KahPee:

Ist das vergrößern, der Länge um 10 schneller als das Vergrößern der Länge 10mal um 1?

Zitat von Luckie:

Desweiteren hätte man sich diese Frage auch schnell durch ausprobieren beantworten können.

Ich denke nicht, dass er dies hätte mit ausprobieren so eindeutig feststellen können! Oder

[himitsu]

Delphi-Quellcode:

var
  a: Array of Integer;
  aLen, i, i2, i3: Integer;
  C, C2: LongWord;

begin
  C := GetTickCount;
  for i2 := 1 to 10000000 do begin
    i := Length(a);

    SetLength(a, i + 1);

    a[i] := 123456;
  End;
  C := GetTickCount - C;

  a := nil;
  aLen := 0;

  C2 := GetTickCount;
  for i2 := 1 to 10000000 do begin
    i := aLen;

    Inc(aLen);
    i3 := (aLen + $FF) and not $FF;
    if i3 <> Length(a) then SetLength(a, i3);

    a[i] := 123456;
  end;
  C2 := GetTickCount - C2;

  Application.MessageBox(PChar(Format('C = %d ms'#13#10'C2 = %d ms', [C, C2])), 'Test');
end;

Zitat:

---------------------------
Test
---------------------------
C = 1094 ms

C2 = 78 ms
---------------------------
OK
---------------------------

[SimStar001]

k überzeugt, aber wieso klappt das ganze bei der ersten methode nicht mit inc(i)? das wäre ja auch noch etwas schneller?

[himitsu]

das Inc fällt hier fast garnicht auf ... könnte auch aLen:=aLen+1; nehmen und es ändert sich nix.


bei obrigen Code (lezter Post), wird einfach nur das Array immer um 1 vergrößert,

ebenso wie hier ... hier wird die Länge auf i gesetzt und i ist 1 größer als die Länge:

Delphi-Quellcode:

var
  a: Array of Integer;
  aLen, i, i2, i3: Integer;
  C, C2: LongWord;

begin
  C := GetTickCount;
  for i2 := 1 to 10000000 do begin
    i := Length(a) + 1;

    SetLength(a, i);

    a[i - 1] := 123456;
  End;
  C := GetTickCount - C;

  a := nil;
  aLen := 0;

  C2 := GetTickCount;
  for i2 := 1 to 10000000 do begin
    i := aLen + 1;

    aLen := i;
    i3 := (aLen + $FF) and not $FF;
    if i3 <> Length(a) then SetLength(a, i3);

    a[i - 1] := 123456;
  end;
  C2 := GetTickCount - C2;

  Application.MessageBox(PChar(Format('C = %d ms'#13#10'C2 = %d ms', [C, C2])), 'Test');
end;

hier wird die länge aus der Zählervariable genommen

Delphi-Quellcode:

var
  a: Array of Integer;
  aLen, i, i2, i3: Integer;
  C, C2: LongWord;

begin
  C := GetTickCount;
  for i2 := 1 to 10000000 do begin
    i := i2;

    SetLength(a, i);

    a[i - 1] := 123456;
  End;
  C := GetTickCount - C;

  a := nil;
  aLen := 0;

  C2 := GetTickCount;
  for i2 := 1 to 10000000 do begin
    i := i2;

    aLen := i;
    i3 := (aLen + $FF) and not $FF;
    if i3 <> Length(a) then SetLength(a, i3);

    a[i - 1] := 123456;
  end;
  C2 := GetTickCount - C2;

  Application.MessageBox(PChar(Format('C = %d ms'#13#10'C2 = %d ms', [C, C2])), 'Test');
end;

wie gesagt, die zuweisung zu den Zählervariablen hat kaum Einfluß: ... hier verbraucht im Vergleich das Kopieren des Arrays sooooo viel Zeit.

Was aber auffäll ist, daß die Schrittweise verwaltung etwas mehr aufwand benötigt.
- 3 Zeilen, statt nur Einer
- es ist unübersichtlicher bzw. fehleranfälliger
- und man muß aLen verwenden, um die Anzahl der tatsächlichen Daten im Array zu bekommen und nich Length(a)

[Luckie]

Zitat von SimStar001:

Ich denke nicht, dass er dies hätte mit ausprobieren so eindeutig feststellen können! Oder

Das mit der Geschwindigkeit eventiull nicht so schnell, aber es ging ja ursprünglich darum ob der Inhalt erhalten bleibt, wenn man das dynamische Array vergrößert.

[SimStar001]

Ok stimmt, das hatte ich schon wieder vergessen...