परिवर्तित std :: वेक्टर <> :: सी में नेट इंटरफ़ेस के लिए इटरेटर ++/CLI

Question

मैं एक देशी सी ++ वर्ग है, जो निम्न विधियों है लपेटकर हूँ:

class Native 
{ 
    public: 
    class Local 
    { 
     std::string m_Str; 
     int m_Int; 
    }; 

    typedef std::vector<Local> LocalVec; 
    typedef LocalVec::iterator LocalIter; 

    LocalIter BeginLocals(); 
    LocalIter EndLocals(); 

    private: 
     LocalVec m_Locals; 
}; 

1) ".NET क्या है रास्ता "इस तरह के इंटरफ़ेस का प्रतिनिधित्व करने का? एक सरणी <> लौटने वाली एक विधि? क्या सरणी <> जेनेरिक में इटरेटर हैं, ताकि मैं BeginLocals() और EndLocals() को कार्यान्वित कर सकूं?

2) स्थानीय को मूल्य संरचना .NET wrapper में घोषित किया जाना चाहिए?

मैं वास्तव में एक नेट स्वाद के साथ लिपटे वर्ग का प्रतिनिधित्व करना चाहते हैं, लेकिन मैं बहुत कामयाब रहे दुनिया के लिए नया हूँ - और इस प्रकार की जानकारी गूगल के लिए ...

Answer 1

Iterators नहीं कर रहे निराशा होती है ".net रास्ता" के लिए बिल्कुल अनुवाद करने योग्य नहीं है, लेकिन इन्हें मोटे तौर पर आईनेमेरेबल < टी> और आईन्यूमेरेटर < टी> द्वारा प्रतिस्थापित किया गया है।

बजाय

vector<int> a_vector; 
    vector<int>::iterator a_iterator; 
    for(int i= 0; i < 100; i++) 
    { 
    a_vector.push_back(i); 
    } 

    int total = 0; 
    a_iterator = a_vector.begin(); 
    while(a_iterator != a_vector.end()) { 
    total += *a_iterator; 
    a_iterator++; 
    } 

आप (ग # में)

List<int> a_list = new List<int>(); 
for(int i=0; i < 100; i++) 
{ 
    a_list.Add(i); 
} 
int total = 0; 
foreach(int item in a_list) 
{ 
    total += item; 
} 

या अधिक स्पष्ट रूप से देखना होगा (foreach वाक्य रचना चीनी पीछे IEnumerator छुपा के बिना):

List<int> a_list = new List<int>(); 
for (int i = 0; i < 100; i++) 
{ 
    a_list.Add(i); 
} 
int total = 0; 
IEnumerator<int> a_enumerator = a_list.GetEnumerator(); 
while (a_enumerator.MoveNext()) 
{ 
    total += a_enumerator.Current; 
} 

के रूप में आप देख सकते हैं, foreach सिर्फ आपके लिए .net enumerator छुपाता है।

तो वास्तव में, ".net रास्ता" लोगों को आसानी से सूची < स्थानीय> आइटम बनाने की अनुमति देगा। यदि आप पुनरावृत्ति को नियंत्रित करना चाहते हैं या संग्रह को थोड़ा अधिक कस्टम बनाना चाहते हैं, तो अपने संग्रह को आईनेमेरेबल < टी> और/या आईसीओलेक्शन < टी> इंटरफेस को भी लागू करें।

ग # करने के लिए एक के पास सीधा अनुवाद काफी तुम क्या मान लिया होगा:

public class Native 
{ 
    public class Local 
    { 
    public string m_str; 
    public int m_int; 
    } 

    private List<Local> m_Locals = new List<Local>(); 

    public List<Local> Locals 
    { 
    get{ return m_Locals;} 
    } 
} 

फिर एक उपयोगकर्ता

foreach(Local item in someNative.Locals) 
{ 
... 
} 

Answer 2

@Phillip करने में सक्षम होगा - धन्यवाद, आपका जवाब वास्तव में मिला मुझे शुरू कर दिया सही दिशा में।

अपने कोड देखकर, और कार्रवाई में Nish की किताब C++/CLI में एक छोटे से अधिक पढ़ने करने के बाद, मैं एक अनुक्रमित संपत्ति है कि प्रबंधित ढेर पर एक स्थानीय उदाहरण के लिए एक स्थिरांक ट्रैकिंग संभाल रिटर्न का उपयोग कर लगता है कि शायद सबसे अच्छा है दृष्टिकोण। मैंने निम्न के जैसा कुछ कार्यान्वित किया:

public ref class Managed 
{ 
    public: 
    ref class Local 
    { 
     String^ m_Str; 
     int m_Int; 
    }; 

    property const Local^ Locals[int] 
    { 
     const Local^ get(int Index) 
     { 
      // error checking here... 
      return m_Locals[Index]; 
     } 
    }; 

    private: 
     List<Local^> m_Locals; 
};