एक निरंतर प्रारंभ करें जो निश्चित सरणी की एक गतिशील सरणी है?

Question

क्या मैं निरंतर गतिशील सरणी सरणी शुरू कर सकता हूं?

हैं:

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

मैं एक initialized निरंतर बना सकते हैं? अगर यह संभव नहीं है

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; 

अगर यह संभव नहीं है, किसी भी कोड में सिर्फ hardwiring कार्य है, जो स्पष्ट रूप से ले लिया होता अलावा अन्य सुझाव मुझे इस सवाल को लिखने से कम समय!

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

यदि आपको गतिशील ar की आवश्यकता है रे, आपको रन-टाइम पर इसे बनाना होगा। आप या तो इसे बना सकते हैं अप सीधे:

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

एक्सई 7 में गतिशील सरणी स्थिरांक घोषित करना संभव है।

सरल मामला:

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;