Question

我正在比较这两种初始化动态数组的方式之间的性能：

Arr := TArray<integer>.Create(1, 2, 3, 4, 5);

和

SetLength(Arr, 5);
Arr[0] := 1;
Arr[1] := 2;
Arr[2] := 3;
Arr[3] := 4;
Arr[4] := 5;

我准备了一个测试，我注意到使用数组“构造函数”需要两倍于另一个方法所需的时间。

测试

uses
  DateUtils;

function CreateUsingSetLength() : TArray<integer>;
begin
  SetLength(Result, 5);
  Result[0] := 1;
  Result[1] := 2;
  Result[2] := 3;
  Result[3] := 4;
  Result[4] := 5;
end;

...

const
  C_COUNT = 10000000;
var
  Start : TDateTime;
  i : integer;
  Arr : TArray<integer>;
  MS1 : integer;
  MS2 : integer;
begin
  Start := Now;
  i := 0;
  while(i < C_COUNT) do
  begin
    Arr := TArray<integer>.Create(1, 2, 3, 4, 5);
    Inc(i);
  end;
  MS1 := MillisecondsBetween(Now, Start);

  Start := Now;
  i := 0;
  while(i < C_COUNT) do
  begin
    Arr := CreateUsingSetLength();
    Inc(i);
  end;
  MS2 := MillisecondsBetween(Now, Start);

  ShowMessage('Constructor = ' + IntToStr(MS1) + sLineBreak + 'Other method = ' + IntToStr(MS2));

在我的机器上进行测试，结果值总是接近以下值：

构造函数= 622

其他方法= 288

为什么数组“构造函数”这么慢？

Answer 1

让我们看一下生成的代码（优化，Win32目标，10.2东京）：

Project152.dpr.34: Arr := TArray<Integer>.Create(1, 2, 3, 4, 5);
004D0D22 8D45F8           lea eax,[ebp-$08]
004D0D25 8B15B84B4000     mov edx,[$00404bb8]
004D0D2B E858BFF3FF       call @DynArrayClear
004D0D30 6A05             push $05
004D0D32 8D45F8           lea eax,[ebp-$08]
004D0D35 B901000000       mov ecx,$00000001
004D0D3A 8B15B84B4000     mov edx,[$00404bb8]
004D0D40 E81FBEF3FF       call @DynArraySetLength
004D0D45 83C404           add esp,$04
004D0D48 8B45F8           mov eax,[ebp-$08]
004D0D4B C70001000000     mov [eax],$00000001
004D0D51 8B45F8           mov eax,[ebp-$08]
004D0D54 C7400402000000   mov [eax+$04],$00000002
004D0D5B 8B45F8           mov eax,[ebp-$08]
004D0D5E C7400803000000   mov [eax+$08],$00000003
004D0D65 8B45F8           mov eax,[ebp-$08]
004D0D68 C7400C04000000   mov [eax+$0c],$00000004
004D0D6F 8B45F8           mov eax,[ebp-$08]
004D0D72 C7401005000000   mov [eax+$10],$00000005
004D0D79 8B55F8           mov edx,[ebp-$08]
004D0D7C 8D45FC           lea eax,[ebp-$04]
004D0D7F 8B0DB84B4000     mov ecx,[$00404bb8]
004D0D85 E842BFF3FF       call @DynArrayAsg

和

Project152.dpr.12: SetLength(Result, 5);
004D0CB2 6A05             push $05
004D0CB4 8BC3             mov eax,ebx
004D0CB6 B901000000       mov ecx,$00000001
004D0CBB 8B15B84B4000     mov edx,[$00404bb8]
004D0CC1 E89EBEF3FF       call @DynArraySetLength
004D0CC6 83C404           add esp,$04
Project152.dpr.13: Result[0] := 1;
004D0CC9 8B03             mov eax,[ebx]
004D0CCB C70001000000     mov [eax],$00000001
Project152.dpr.14: Result[1] := 2;
004D0CD1 8B03             mov eax,[ebx]
004D0CD3 C7400402000000   mov [eax+$04],$00000002
Project152.dpr.15: Result[2] := 3;
004D0CDA 8B03             mov eax,[ebx]
004D0CDC C7400803000000   mov [eax+$08],$00000003
Project152.dpr.16: Result[3] := 4;
004D0CE3 8B03             mov eax,[ebx]
004D0CE5 C7400C04000000   mov [eax+$0c],$00000004
Project152.dpr.17: Result[4] := 5;
004D0CEC 8B03             mov eax,[ebx]
004D0CEE C7401005000000   mov [eax+$10],$00000005

很明显，为＆＃34;构造函数生成的代码＆＃34;呼叫根本不那么优化。

正如您所看到的，＆＃34;构造函数＆＃34;代码首先清除，分配和填充匿名数组（在[ebp-$08]），最后将其分配给Arr变量（[ebp-$04]）。这主要是为什么它变慢了。

在较新版本中，还有第三种方式：

Arr := [1, 2, 3, 4, 5];

但这会产生与＆＃34;构造函数完全相同的代码＆＃34;句法。但你可以加快速度：

const
  C_ARR = [1, 2, 3, 4, 5]; // yes, dynarray const!

和

Arr := C_ARR;

这只生成一次动态数组，引用计数为-1，并且在循环中，只需执行一个赋值（好吧，在_DynArrayAsg中，实际上是一个副本 - 但这仍然更快）：

Project152.dpr.63: Arr := C_ARR;
004D0E60 8D45FC           lea eax,[ebp-$04]
004D0E63 8B15C4864D00     mov edx,[$004d86c4]
004D0E69 8B0DB84B4000     mov ecx,[$00404bb8]
004D0E6F E858BEF3FF       call @DynArrayAsg

REMARK：

但是，正如@DavidHeffernan评论的那样，在现实生活中，这些性能差异几乎不会被注意到。您通常不会在紧密循环中初始化此类阵列，并且在一次性情况下，差异为几纳秒，在整个程序运行期间您将不会注意到这一点。 < / p>

备注2：

似乎有些混乱。类型TArray<Integer>与array of Integer完全相同。对于动态数组，类或其他类型的包装器都不是。它们只是简单的动态数组而没有别的。构造函数语法可以应用于两者。 唯一的区别在于类型兼容性。 TArray<Integer>可以用作ad-hoc类型声明，并且所有TArray<Integer>都是类型兼容的。

为什么动态数组“构造函数”比SetLength和元素初始化慢得多？

1 个答案:

REMARK：

备注2：