डेल्फी 6 के साथ प्रारंभिक समेकित प्रकारों को फिर से कैसे शुरू करें और "सीमाओं से बाहर" त्रुटि से बचें?

Question

मैं डेल्फी 6 पेशेवर का उपयोग कर रहा हूं। मुझे DLL libraty कि एक enumberated प्रकार इस प्रकार की घोषणा के साथ इंटरफ़ेस हूँ:

TExtDllEnum = (ENUM1 = $0, ENUM2 = $1, ENUM3 = $2, ENUM4 = $4, ENUM5 = $8, ENUM6 = $10); 

आप देख सकते हैं initialized मूल्यों सन्निहित नहीं हैं। इस प्रकार अगर मैं लूप लिए एक का उपयोग कर प्रकार पुनरावृति करने की कोशिश:

var 
    e: TExtDllEnum; 
begin 
    for e := Low(TExtToDllEnum) to High(TExtToDllEnum) do 
    ... // More code 
end; 

डेल्फी अभी भी 1 प्रत्येक पाश मंगलाचरण द्वारा ई वृद्धि कर देता है और इस तरह कि enumerated प्रकार के सदस्य (उदाहरण के लिए नहीं कर रहे हैं ई के लिए संख्यात्मक मान बनाता है, ' 3 '), और जिसके परिणामस्वरूप' सीमा से बाहर 'त्रुटि हुई। मैं लूप में समेकित प्रकार को कैसे पुन: सक्रिय कर सकता हूं जो गणना के प्रकार के लिए केवल वैध मान उत्पन्न करता है?

धन्यवाद।

Answer 1

स्थिरांक का एक सेट को परिभाषित करके ...

type 
    TExtDllEnum = (ENUM1 = $0, ENUM2 = $1, ENUM3 = $2, ENUM4 = $4, ENUM5 = $8, ENUM6 = $10); 

const 
    CExtDllEnumSet = [ENUM1, ENUM2, ENUM3, ENUM4, ENUM5, ENUM6]; 


var 
    e: TExtDllEnum; 
begin 
    e := Low(TExtDllEnum); 
    while e <= High(TExtDllEnum) do 
    begin 
    if e in CExtDllEnumSet then 
     WriteLn(Ord(e)); 

    Inc(e); 
    end; 

    ReadLn; 
end. 

---

और एक इटरेटर के रूप में कार्यान्वित - बस मजेदार के लिए ...

type 
    TExtDllEnum = (ENUM1 = $0, ENUM2 = $1, ENUM3 = $2, ENUM4 = $4, ENUM5 = $8, ENUM6 = $10); 
const 
    CExtDllEnumSet = [ENUM1, ENUM2, ENUM3, ENUM4, ENUM5, ENUM6]; 

type 
    TMyIterator = class 
    private 
    FValue: TExtDllEnum; 
    public 
    constructor Create; 
    function Next: TExtDllEnum; 
    function HasNext: Boolean; 
    end; 

    constructor TMyIterator.Create; 
    begin 
    FValue := Low(TExtDllEnum); 
    end; 

    function TMyIterator.HasNext: Boolean; 
    begin 
    Result := FValue <= High(TExtDllEnum); 
    end; 

    function TMyIterator.Next: TExtDllEnum; 
    begin 
    Result := FValue; 

    repeat 
     Inc(FValue); 
    until (FValue in CExtDllEnumSet) or (FValue > High(TExtDllEnum)) 
    end; 

var 
    MyIterator: TMyIterator; 
begin 
    MyIterator := TMyIterator.Create; 

    while MyIterator.HasNext do 
    WriteLn(Ord(MyIterator.Next)); 

    MyIterator.Free; 

    ReadLn; 
end. 

Answer 2

जहां तक ​​मुझे याद है, वैसे भी जिस तरह से आप चाहते हैं उसे फिर से शुरू करने का कोई तरीका नहीं है। यदि गणना अक्सर नहीं बदला जाता है, तो "इंडेक्स सरणी" घोषित करने के लिए एक वर्कअराउंड हो सकता है, जो आपको इच्छित तरीके से फिर से शुरू करने देता है। चाल आप गणन से अधिक पुनरावृति में नहीं आता है, लेकिन एक सूचकांक जो आप बारी में एक मान्य तत्व करने के लिए "परिवर्तित" कर सकते हैं enum में खत्म हो गया:

मुझे लगता है मैं कोड में बेहतर विचार की व्याख्या कर सकते हैं:

const 
    ExtDllEnumElements = 6; 
    EnumIndexArray: array[0..ExtDllEnumElements - 1] of TExtDllEnum = (ENUM1, ENUM2, ENUM3, ENUM4, ENUM5, ENUM6); 
var 
    I: Integer; 
begin 
    for I := Low(EnumIndexArray) to High(EnumIndexArray) do 
    WhateverYouWantWith(EnumIndexArray[I]); 
end; 

Answer 3

आप कर सकते हैं

नहीं करता है, तो मान द्विआधारी भारित इस

var 
    e: TExtDllEnum; 
begin 
    e := 0; 
    While e <= High(TExtToDllEnum) do 
    begin 
     ... // More code 
     e := Power(2, e); 
    end; 

end; 

Answer 4

की तरह थोड़ी देर के पाश का उपयोग करते समय आप गणना परिभाषित कोशिश कर रहे हैं

012,

TExtDllEnum = (ENUM1 = $0, ENUM2 = $1, ENUM3 = $2, ENUM4 = $4, ENUM5 = $8, ENUM6 = $10); 

आप वास्तव में गणित प्रकार को परिभाषित करते हैं जिसमें 17 ($ 10 + 1) संभावित मान होते हैं। वह documented है।

केवल असाइन किए गए गणना स्थिरांक पर पुनरावृत्ति को लागू करने के कई तरीके हैं (अन्य उत्तरों देखें), लेकिन जिस तरह से आप इसे कर रहे हैं, आप 17 से अधिक मानों को पुन: सक्रिय करते हैं, और इसे बदला नहीं जा सकता है।

यहाँ एक और यात्रा उदाहरण के तथ्य यह है कि ENUM1 को छोड़कर सभी ENUMx मान 2 की शक्तियों रहे हैं का उपयोग करता है:

type 
    TExtDllEnum = (ENUM1 = $0, ENUM2 = $1, ENUM3 = $2, 
       ENUM4 = $4, ENUM5 = $8, ENUM6 = $10); 
var 
    e: TExtDllEnum; 

begin 
    e:= Low(TExtDllEnum); 
    repeat 
    [..] 
    if e = ENUM1 then e:= ENUM2 
    else if e = High(TExtDllEnum) then Break 
    else e:= e shl 1; 
    until False; 
end;