9

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

如果：

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;

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

4

3 回答 3

27

在 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));
  J := 0;
  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的回答。

于 2012-05-10T00:49:06.413 回答
14

在 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;
于 2014-09-02T11:51:07.507 回答
0

您可以使用此方法：

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;
于 2017-02-27T08:20:27.373 回答