एसटीएल सूची के माध्यम से आप पीछे की तरफ कैसे जाते हैं?

Question

मैं विंडोज और मैक के बीच कुछ क्रॉस-प्लेटफ़ॉर्म कोड लिख रहा हूं।

यदि सूची :: अंत() "एक पुनरावर्तक लौटाता है जो किसी सूची में अंतिम तत्व को सफल करने वाले स्थान को संबोधित करता है" और किसी सूची को आगे बढ़ाने के दौरान चेक किया जा सकता है, पीछे की तरफ जाने का सबसे अच्छा तरीका क्या है?

इस कोड workson मैक लेकिन Windows पर नहीं (पहला तत्व परे घटती नहीं कर सकते हैं):

list<DVFGfxObj*>::iterator iter = m_Objs.end(); 
for (iter--; iter!=m_Objs.end(); iter--)// By accident discovered that the iterator is circular ? 
{ 
} 

इस विंडोज पर काम करता है:

list<DVFGfxObj*>::iterator iter = m_Objs.end(); 
    do{ 
     iter--; 
    } while (*iter != *m_Objs.begin()); 

वहाँ एक और तरीका पिछड़े पार करने के लिए है कि है एक लूप में लागू किया जा सकता है?

Answer 1

पुनरावर्तक के बजाय रिवर्स_इटरेटर का उपयोग करें। शुरू करने के बजाय rbegin() & rend() का उपयोग करें() & अंत()।

एक और संभावना, यदि आप BOOST_FOREACH मैक्रो का उपयोग करना चाहते हैं तो बूस्ट 1.36.0 में प्रस्तुत BOOST_REVERSE_FOREACH मैक्रो का उपयोग करना है।

Answer 2

शायद आप रिवर्स इटेटरेटर्स चाहते हैं। स्मृति से:

list<DVFGfxObj*>::reverse_iterator iter = m_Objs.rbegin(); 
for(; iter != m_Objs.rend(); ++iter) 
{ 
} 

Answer 3

जैसा कि पहले ही फारुशियो, उपयोग reverse_iterator ने उल्लेख किया:

for (std::list<int>::reverse_iterator i = s.rbegin(); i != s.rend(); ++i) 

Answer 4

यह काम करना चाहिए:

list<DVFGfxObj*>::reverse_iterator iter = m_Objs.rbegin(); 
for (; iter!= m_Objs.rend(); iter++) 
{ 
} 

Answer 5

सबसे अच्छा/सबसे आसान तरीका उल्टा करने के लिए पुनरावृति एक सूची है (के रूप में पहले से ही कहा गया है) रिवर्स इटरेटर्स rbegin/rend का उपयोग करने के लिए।

हालांकि, मैं यह उल्लेख करना चाहता था कि रिवर्स इटरेटर्स को "वर्तमान" पुनरावर्तक स्थिति को एक-एक करके (मानक पुस्तकालय के जीएनयू कार्यान्वयन पर) को लागू करने के लिए लागू किया गया है।

इस श्रृंखला के लिए रिवर्स में एक सीमा के आगे के रूप में ही अर्थ विज्ञान के लिए [शुरू, अंत) कार्यान्वयन को आसान बनाने के लिए किया जाता है, ताकि और [rbegin, उखड़ना)

इसका मतलब क्या है कि एक अपसंदर्भन है इटरेटर एक नया अस्थायी बनाने शामिल है, और उसके बाद हर बार यह decrementing, :

reference 
    operator*() const 
    { 
_Iterator __tmp = current; 
return *--__tmp; 
    } 

इस प्रकार, एक reverse_iterator अपसंदर्भन एक सामान्य इटरेटर की तुलना में धीमी है।

हालांकि, इसके बजाय आप अपने आप को यात्रा रिवर्स अनुकरण करने के लिए नियमित रूप से द्विदिश iterators उपयोग कर सकते हैं, इस भूमि के ऊपर से परहेज:

for (iterator current = end() ; current != begin() ; /* Do nothing */) 
{ 
    --current; // Unfortunately, you now need this here 
    /* Do work */ 
    cout << *current << endl; 
} 

परीक्षण इस समाधान से पता चला है ~ 5 गुना तेजी से प्रत्येक भिन्नता में इस्तेमाल के लिए होने के लिए लूप का शरीर।

नोट: उपरोक्त कोड के साथ परीक्षण नहीं किया गया था, क्योंकि std :: cout बाधा बन गई होगी।

यह भी ध्यान दें: 'दीवार घड़ी का समय' अंतर ~ 5 सेकंड था जिसमें 10 मिलियन तत्वों की एक std :: सूची आकार था। तो, वास्तव में, जब तक कि आपके डेटा का आकार इतना बड़ा न हो, बस rbegin() rend() को चिपकाएं!