初始化一个固定数组的动态数组常量？

Question

我可以初始化一个恒定的动态数组吗？

如果:

type
  tNamePair = array[1..2] of String;
  tPairList = array of tNamePair;

如何创建初始化常量？我无法得到以下代码编译:

const
  PairList: tPairList = ( ('One', '1'), 
                          ('Two', '2'),
                          ('Three', '3'));

如果那是不可能的,可以用固定数组初始化一个固定的固定数组:

 type
    tPairList: array[1..3] of tNamePair;

如果这不可能,可以使用记录初始化常量动态数组:

tNamePair = record 
              English: String;
              Number: String;
            end;           
tPairList = array of tNamePair;

如果不可能,可以使用记录初始化常量固定数组:

tNamePair = record 
              English: String;
              Number: String;
            end;           
tPairList = array[1..3] of tNamePair;

如果这是不可能的,除了代码中的硬连线分配之外的任何建议,坦率地说,这比我撰写这个问题花费的时间少!

Answer 1

在XE7之前,您无法创建动态数组常量.必须在编译时知道常量,但在运行时分配动态数组.

甲固定的阵列固定阵列可以在编译时被声明:

type
  tNamePair = array[1..2] of String;
  tPairList = array[1..3] of tNamePair;

const
  PairList: tPairList = ( ('One', '1'),
                          ('Two', '2'),
                          ('Three', '3'));

甲固定的阵列记录也可以在编译时宣称:

type
  tNamePair = record
              English: String;
              Number: String;
            end;
  tPairList = array[1..3] of tNamePair;

const
  PairList: tPairList = ( (English: 'One'; Number: '1'),
                          (English: 'Two'; Number: '2'),
                          (English: 'Three'; Number: '3'));

如果需要动态数组,则必须在运行时构造它.您可以直接构建它:

type
  tNamePair = array[1..2] of String;
  tPairList = array of tNamePair;

var
  PairList: tPairList;

initialization
  SetLength(PairList, 3);
  PairList[0][1] := 'One';
  PairList[0][2] := '1';
  PairList[1][1] := 'Two';
  PairList[1][2] := '2';
  PairList[2][1] := 'Three';
  PairList[2][2] := '3';
end.

或者,您可以定义编译时常量固定数组,并在运行时将其复制到动态数组中:

type
  tNamePair = array[1..2] of String;
  tPairList = array[1..3] of tNamePair;
  tPairListDyn = array of tNamePair;

const
  PairList: tPairList = ( ('One', '1'),
                          ('Two', '2'),
                          ('Three', '3'));

function MakePairListDyn(const Pairs: tPairList): tPairListDyn;
var
  I, J: Integer;
begin
  SetLength(Result, Length(Pairs));
  for I := Low(Pairs) to High(Pairs) do begin
    Result[J] := Pairs[I];
    Inc(J);
  end;
end;

var
  Pairs: tPairListDyn;

initialization
  Pairs := MakePairListDyn(PairList);
end.

对于XE7后的情况,请参阅下面的@LURD答案.

Answer 2

在XE7中,可以声明动态数组常量.

简单案例:

const
  a: TArray<String> = ['Delphi','XE7'];

在您的示例中,这将编译:

type
  tNamePair = TArray<String>;
  tPairList = TArray<tNamePair>;

const
  PairList: tPairList = [['One', '1'],['Two', '2'],['Three', '3']];

要创建记录的动态数组,可以在运行时完成,如下所示:

Type
  TNamePair = record
    English: String;
    Number: String;
    class function Define(_English,_Number: String): TNamePair; static;
  end;
  TPairList = TArray<TNamePair>;

class function TNamePair.Define(_English, _Number: String): TNamePair;
begin
  Result.English := _English;
  Result.Number := _Number;
end;

var
  pl : TPairList;
begin
  pl := [TNamePair.Define('A','1'),TNamePair.Define('B','2')];
  ...
end;