डेल्फी SetLength कस्टम अनुक्रमण

Question

डेल्फी में, यह प्रकार

var 
    Arr: array[2..N] of MyType; 

जो N - 1 तत्वों 2 से एन

को अनुक्रमित हम बजाय एक गतिशील की घोषणा तो की एक सरणी है की एक सरणी बनाने के लिए संभव है सरणी

var 
    Arr: array of MyType 

और बाद में

के माध्यम से N - 1 तत्वों का आवंटन 210

SetLength(Arr, N - 1) 

तब तत्वों को 0 से एन - 2 तक अनुक्रमित किया जाएगा। क्या उन्हें इसके बजाय 2 से एन (कहें) से अनुक्रमित करना संभव है?

Answer 1

नहीं, डेल्फी गतिशील सरणी में हमेशा शून्य से अनुक्रमित किया जाता है।

Answer 2

केवल एक चीज है कि आप उस की नकल करता है इस व्यवहार संकेत उपयोग कर रहा है क्या कर सकते हैं ..

type 
    TMyTypeArr = array [ 0..High(Integer) div sizeof(MyType) - 1 ] of Mytype; 
    PMyTypeArr = ^TMyTypeArr; 
var 
    x: ; 
    A: PMyTypeArr; 
begin 
    SetLength(A, 2); 
    x := PMyTypeArr(@A[ 0 ]); Dec(PMyType(x), 2); // now [2,4> is valid. 
    x[2] := Get_A_MyType(); 
end; 

कृपया ध्यान दें कि किसी भी श्रेणी की जाँच खो देते हैं, और गठबंधन है कि एक बहुत बहुत बुरा विचार है गैर शून्य से शुरू होने सरणियों के साथ !

Answer 3

यदि आपको वास्तव में इस अनुक्रमण की आवश्यकता है, तो आप एक साधारण "अनुवाद" फ़ंक्शन लिख सकते हैं, जो 2 से एन तक की श्रेणी में इंडेक्स आकृति प्राप्त करेगा और केवल 0 से एन-2 तक इंडेक्स वापस कर देगा, केवल घटाकर 2 पैरामीटर से, उदाहरण के लिए:

function translate(i : integer) : integer; 
begin 
    result := i - 2; 
end; 

और तुम इस तरह अपने सरणी कह सकते हैं:

array[translate(2)] 

बेशक

, तो आप इसके अलावा में सीमा समारोह के भीतर जाँच कर सकता है, और हो सकता है आप दे सकते हैं यह एक छोटा नाम है।

या और भी बेहतर, इस तरह एक समारोह के साथ सरणी के लिए पूरे पहुँच लपेट:

function XYZ(i : integer) : MyType; 
begin 
    // Do range checking here... 
    result := MyArray[i - 2]; 
end; 

आशा इस मदद करता है

Answer 4

हाँ! एक चाल का उपयोग करके!
सबसे पहले एक नया प्रकार घोषित करें। मैं कक्षा के बजाय रिकॉर्ड प्रकार का उपयोग करता हूं क्योंकि रिकॉर्ड का उपयोग करना थोड़ा आसान है।

type 
    TMyArray = record 
    strict private 
    FArray: array of Integer; 
    FMin, FMax:Integer; 
    function GetItem(Index: Integer): Integer; 
    procedure SetItem(Index: Integer; const Value: Integer); 
    public 
    constructor Create(Min, Max: integer); 
    property Item[Index: Integer]: Integer read GetItem write SetItem; Default; 
    property Min: Integer read FMin; 
    property Max: Integer read FMax; 
    end; 

RECORDTYPE साथ

परिभाषित, अब आप कोड का एक सा लागू करने की आवश्यकता:

constructor TMyArray.Create(Min, Max: integer); 
begin 
    FMin := Min; 
    FMax := Max; 
    SetLength(FArray, Max + 1 - Min); 
end; 

function TMyArray.GetItem(Index: Integer): Integer; 
begin 
    Result := FArray[Index - FMin]; 
end; 

procedure TMyArray.SetItem(Index: Integer; const Value: Integer); 
begin 
    FArray[Index - FMin] := Value; 
end; 

प्रकार घोषित साथ, आप अब इसका इस्तेमाल करने शुरू कर सकते हैं:

var 
    Arr: TMyArray; 
begin 
    Arr := TMyArray.Create(2, 10); 
    Arr[2] := 10; 

यह वास्तव में एक विशिष्ट सीमा के साथ सरणी बनाने के लिए एक साधारण चाल है और यदि आप चाहें तो इसे अधिक लचीला बना सकते हैं। या इसे एक वर्ग में परिवर्तित करें। निजी तौर पर, मैं इन प्रकार के सरल प्रकारों के लिए रिकॉर्ड पसंद करता हूं।