Inicializar una constante que es una matriz dinámica de arreglos fijos?

Question

¿Puedo inicializar una matriz constante de matrices?

Si:

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

¿Cómo puedo crear una constante inicializada? No puedo conseguir el código de abajo de compilación:

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

Si eso no es posible, puede una constante de matriz fijo ser inicializado con una matriz fijo:

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

Si eso no es posible, puede una constante dinámico matriz se inicializa con un registro :

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

si eso no es posible, se puede inicializar una constante fija matriz con un registro :

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

Si eso no es posible, alguna sugerencia que no sean sólo cableado asignaciones en el código, que francamente se han tomado ¡Menos tiempo que componer esta pregunta!

Answer 1

Antes de XE7 no se podían crear dinámicas constantes de matriz. Las constantes deben conocerse en tiempo de compilación, pero las matrices dinámicas se asignan en tiempo de ejecución.

Una matriz fija de fijos matrices puede ser declarada en tiempo de compilación:

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

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

A fija gama de registros también puede ser declarado en tiempo de compilación:

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')); 

Si necesita un dinámico ar Ray, tienes que construirlo en tiempo de ejecución. Usted puede construir directamente:

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. 

O puede definir un tiempo de compilación constante fijo matriz y copiarla en el dinámica matriz en tiempo de ejecución:

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. 

Para la situación post XE7 ver la respuesta de @LURD a continuación.

Answer 2

En XE7 es posible declarar constantes de matriz dinámica.

caso simple:

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

En su ejemplo de este compila:

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

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

---

Para crear una matriz dinámica de un registro, se puede hacer en tiempo de ejecución así:

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

Puede utilizar este método:

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;