std :: list

Question

में लगातार दो तत्वों की तुलना करें मैं सूची के माध्यम से एक std :: सूची में लगातार दो तत्वों की तुलना करना चाहता हूं। तत्व i + 1 तक पहुंचने का सही तरीका क्या है जबकि मेरा इटरेटर तत्व पर है? धन्यवाद Cobe

Answer 1

बूस्ट सिर्फ इतना है कि इस प्रयोजन के लिए एक उपयोगिता next कहा जाता है (और इसके उलटा, prior) है।

*itr == *next(itr) 

संपादित करें: लेकिन, अगर हम पीछे हटना जंगल को देखने के लिए, असली सवाल है, क्यों कस्टम लिखने अपने adjacent_find समारोह? (मैं निकोला बोनेली के जवाब को स्वीकार करने की सलाह देता हूं।) यह एसटीएल का हिस्सा है, और बूस्ट का उपयोग करने की आवश्यकता नहीं है, अगर आपका कोड बूस्ट का उपयोग नहीं करता है (इसे इंगित करने के लिए टिप्पणी करने वालों के लिए धन्यवाद)।

Answer 2

सबसे आसान तरीका दो पुनरावर्तकों को पकड़ना होगा (क्योंकि आपको किसी भी तरह से अंतिम रूप से रोकना होगा)।

इसलिए जब पाश शुरू होता है first list.begin() और दूसरा list.begin()+1 है

std::list<int>::const_iterator second = list.begin(), 
           end = list.end(); 

if (second != end) // Treat empty list 
    for(std::list<int>::const_iterator first = second++; // Post-increment 
     second != end; 
     ++first, ++second) 
    { 
     //... 
    } 

ध्यान दें कि firstsecond की post-incrementation साथ आरंभ नहीं हो जाता।

Chris Jester-Young points out कि को बढ़ावा देने next और prior कार्य करता है, हालांकि मैं इन कार्यों (मेरे पापों के लिए) से परिचित नहीं हूँ उन्हें लागू करने (विशेष रूप से यह देखते हुए कि list द्विदिश iterators है) तुच्छ है।

template <class Iterator> 
Iterator next(Iterator i) // Call by value, original is not changed 
{ 
    return ++i; 
} 
// Implementing prior is left as an exercise to the reader ;o) 

मेरे लग रहा है कि next के उपयोग इस समस्या को सूट नहीं करता है और साथ ही दोनों iterators को बनाए रखने के रूप में के बाद से आप वाकई next(i) बराबर end() हर बार इस्तेमाल करने पर नहीं है बनाने के लिए याद है।

---

संपादन:

• बग को ठीक करता है, तो सूची Luc Touraille की टिप्पणी का खाली धन्यवाद है।
• next के संदर्भ में जोड़ें और मुझे क्यों लगता है कि यह इस उपयोग-मामले में फिट नहीं है।

Answer 3

एसटीएल adjacent_find() एल्गोरिदम प्रदान करता है जिसका उपयोग लगातार दो बराबर तत्वों को खोजने के लिए किया जा सकता है। एक कस्टम predicate के साथ एक संस्करण भी है।

ये प्रोटोटाइप हैं:

template <class ForwardIterator> 
    ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last); 

template <class ForwardIterator, class BinaryPredicate> 
    ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last, 
            BinaryPredicate pred); 

Answer 4

सूची, एक प्रतिवर्ती कंटेनर है इसलिए इसकी iterators द्वि-दिशा Iterators कर रहे हैं, जो आगे इटरेटर है, जो मैं यकीन है कि मतलब है कि आप यह कर सकते हैं कर रहा हूँ का एक मॉडल है (या कुछ बराबर, यदि आप एक पाश आदि के बीच) को तोड़ते से एलर्जी कर रहे हैं:

if (!l.empty()) { 
    for (list<T>::const_iterator i = l.begin();;) { 
     const T &a = *i; 
     ++i; 
     if (i == l.end()) break; 
     do_comparison(a, *i); 
    } 
} 

आप नहीं कर सका है कि एक इनपुट इटरेटर के साथ हैं, क्योंकि उन के साथ मूल्यों केवल "मौजूद" जब तक क्योंकि आपके पास एक इटरेटर है। लेकिन आप फॉरवर्ड इटरेटर के साथ कर सकते हैं।

Answer 5

for (list<int>::iterator it = test.begin(); it!=test.end(); it++) { 
     cout<<*it<<":\t"; 
     list<int>::iterator copy = it; 
     for(list<int>::iterator it2 = ++copy; it2!=test.end();it2++){ 
      cout<<*it2<<"\t"; 
     } 
     cout<<endl; 
    }