Question

我可以初始化一个常量的动态数组吗？

如果：

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

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

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

如果不可能，可以使用固定数组初始化常量 fixed 数组：

 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.

或者您可以定义编译时常量 fixed 数组并在运行时将其复制到 dynamic 数组中：

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;

Answer 3

您可以使用此方法：

const
  C_ARRAY_CODE : array ['a'..'d'] of string = ('01','02','03','04');
var Conter:Char;
begin
  //Use With Loop
  for Conter := Low(C_ARRAY_CODE) to high(C_ARRAY_CODE) do
    ShowMessage(C_ARRAY_CODE[Conter]);

  //Use Direct
  ShowMessage(C_ARRAY_CODE['a']);
end;

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

3 个答案: