क्या आप इसके माध्यम से std :: सूची से तत्वों को हटा सकते हैं?

Question

मैं कोड है कि इस तरह दिखता है मिल गया है:

for (std::list<item*>::iterator i=items.begin();i!=items.end();i++) 
{ 
    bool isActive = (*i)->update(); 
    //if (!isActive) 
    // items.remove(*i); 
    //else 
     other_code_involving(*i); 
} 
items.remove_if(CheckItemNotActive); 

मैं, निष्क्रिय आइटम के तुरंत बाद उन्हें अपडेट हटाने inorder सूची फिर से चलने से बचना चाहते हैं। लेकिन अगर मैं टिप्पणी-आउट लाइन जोड़ता हूं, तो मुझे i++ पर एक त्रुटि मिलती है: "इटेटरेटर सूची बढ़ाना नहीं है"। मैंने कुछ विकल्पों की कोशिश की जो कथन में वृद्धि नहीं हुईं, लेकिन मुझे काम करने के लिए कुछ भी नहीं मिला।

आइटम को हटाने के लिए सबसे अच्छा तरीका क्या है जब आप std :: सूची चल रहे हैं?

Answer 1

आपको पहले इटरेटर को (i ++ के साथ) बढ़ाना होगा और फिर पिछले तत्व को हटा देना होगा (उदा।, I ++ से लौटाए गए मान का उपयोग करके)। तुम इतनी तरह थोड़ी देर के पाश करने के लिए कोड बदल सकते हैं:

std::list<item*>::iterator i = items.begin(); 
while (i != items.end()) 
{ 
    bool isActive = (*i)->update(); 
    if (!isActive) 
    { 
     items.erase(i++); // alternatively, i = items.erase(i); 
    } 
    else 
    { 
     other_code_involving(*i); 
     ++i; 
    } 
} 

Answer 2

आप क्या करना चाहते हैं:

i= items.erase(i); 

कि सही ढंग से स्थान इटरेटर के बाद आप निकाल दिया करने के लिए बात करने के लिए इटरेटर अद्यतन करेगा।

Answer 3

std :: remove_if एल्गोरिदम का उपयोग करें।

संपादित करें: 1. संग्रह तैयार: की तरह संग्रह के साथ काम करने के लिए किया जाना चाहिए। 2. प्रक्रिया संग्रह।

यदि आप इन चरणों को मिश्रित नहीं करेंगे तो जीवन आसान होगा।

1. std :: remove_if। या सूची :: remove_if (आप जानते हैं कि आप नहीं TCollection साथ सूची के साथ काम करते हैं और अगर)
2. std :: for_each

Answer 4

हटाने केवल iterators है कि तत्वों कि निकाल दिए जाते हैं को इंगित अमान्य हो जाएगा।

तो इस मामले में * i को हटाने के बाद, मुझे अवैध कर दिया गया है और आप इसमें वृद्धि नहीं कर सकते हैं।

आप जो कर सकते हैं वह पहले तत्व के इटरेटर को हटाया जाता है जिसे हटाया जाना है, फिर इटरेटर को बढ़ाएं और फिर सहेजे गए को हटा दें।

Answer 5

आप Kristo के जवाब का संयोजन करने की ज़रूरत है और MSN के:

// This implementation of update executes other_code_involving(Item *) if 
// this instance needs updating. 
// 
// This method returns true if this still needs future updates. 
// 
bool Item::update(void) 
{ 
    if (m_needsUpdates == true) 
    { 
     m_needsUpdates = other_code_involving(this); 
    } 

    return (m_needsUpdates); 
} 

// This call does everything the previous loop did!!! (Including the fact 
// that it isn't deleting the items that are erased!) 
items.remove_if(std::not1(std::mem_fun(&Item::update))); 

Answer 6

विकल्प:

// Note: Using the pre-increment operator is preferred for iterators because 
//  there can be a performance gain. 
// 
// Note: As long as you are iterating from beginning to end, without inserting 
//  along the way you can safely save end once; otherwise get it at the 
//  top of each loop. 

std::list< item * >::iterator iter = items.begin(); 
std::list< item * >::iterator end = items.end(); 

while (iter != items.end()) 
{ 
    item * pItem = *iter; 

    if (pItem->update() == true) 
    { 
     other_code_involving(pItem); 
     ++iter; 
    } 
    else 
    { 
     // BTW, who is deleting pItem, a.k.a. (*iter)? 
     iter = items.erase(iter); 
    } 
} 

बेशक

, सबसे अधिक कुशल और अधिक सर्द ® एसटीएल savy बात कुछ इस तरह होगा क्रिस्टो के जवाब के लिए लूप संस्करण के लिए।

आप कुछ दक्षता खो देते हैं, आप पीछे जाते हैं और फिर हटाते समय फिर से आगे बढ़ते हैं लेकिन अतिरिक्त इटरेटर वृद्धि के बदले में आप लूप स्कोप में घोषित इटरेटर और कोड को थोड़ा क्लीनर देख सकते हैं। क्या चुनना है इस पल की प्राथमिकताओं पर निर्भर करता है।

उत्तर पूरी तरह से समय से बाहर था, मुझे पता है ...

typedef std::list<item*>::iterator item_iterator; 

for(item_iterator i = items.begin(); i != items.end(); ++i) 
{ 
    bool isActive = (*i)->update(); 

    if (!isActive) 
    { 
     items.erase(i--); 
    } 
    else 
    { 
     other_code_involving(*i); 
    } 
} 

Answer 7

मुझे लगता है कि तुम वहाँ एक बग है, मैं इस तरह से कोड डाल दें:

for (std::list<CAudioChannel *>::iterator itAudioChannel = audioChannels.begin(); 
      itAudioChannel != audioChannels.end();) 
{ 
    CAudioChannel *audioChannel = *itAudioChannel; 
    std::list<CAudioChannel *>::iterator itCurrentAudioChannel = itAudioChannel; 
    itAudioChannel++; 

    if (audioChannel->destroyMe) 
    { 
     audioChannels.erase(itCurrentAudioChannel); 
     delete audioChannel; 
     continue; 
    } 
    audioChannel->Mix(outBuffer, numSamples); 
} 

Answer 8

यहाँ एक for पाश कि सूची और वेतन वृद्धि iterates या किसी आइटम की स्थिति में इटरेटर revalidates का उपयोग कर एक उदाहरण है सूची के ट्रैवर्सल के दौरान हटाया जा रहा है।

for(auto i = items.begin(); i != items.end();) 
{ 
    if(bool isActive = (*i)->update()) 
    { 
     other_code_involving(*i); 
     ++i; 

    } 
    else 
    { 
     i = items.erase(i); 

    } 

} 

items.remove_if(CheckItemNotActive); 

Answer 9

आप std::list एक कतार की तरह के बारे में सोच है, तो आप विपंक्ति और सभी आइटम है कि आप रखना चाहते हैं enqueue सकते हैं, लेकिन केवल विपंक्ति (और enqueue नहीं) आइटम आप निकालना चाहते हैं। यहाँ एक उदाहरण है जहाँ मैं संख्या 1-10 से युक्त एक सूची से 5 निकालना चाहते है ...

std::list<int> myList; 

int size = myList.size(); // The size needs to be saved to iterate through the whole thing 

for (int i = 0; i < size; ++i) 
{ 
    int val = myList.back() 
    myList.pop_back() // dequeue 
    if (val != 5) 
    { 
     myList.push_front(val) // enqueue if not 5 
    } 
} 

myList अब केवल संख्या 1-4 और 6-10 होगा।

Answer 10

आप

std::list<item*>::iterator i = items.begin(); 
while (i != items.end()) 
{ 
    bool isActive = (*i)->update(); 
    if (!isActive) { 
     i = items.erase(i); 
    } else { 
     other_code_involving(*i); 
     i++; 
    } 
} 

लिख सकते हैं आप std::list::remove_if साथ बराबर कोड है, जो कम वर्बोज़ और अधिक स्पष्ट

items.remove_if([] (item*i) { 
    bool isActive = (*i)->update(); 
    if (!isActive) 
     return true; 

    other_code_involving(*i); 
    return false; 
}); 

std::vector::erasestd::remove_if मुहावरा इस्तेमाल किया जाना चाहिए जब आइटम के बजाय एक वेक्टर है है लिख सकते हैं ओ (एन) पर कॉम्पेक्सिटी रखने की एक सूची - या यदि आप जेनेरिक कोड लिखते हैं और आइटम एक कंटेनर हो सकते हैं जिसमें एकल आइटम (वेक्टर की तरह) को मिटाने का कोई प्रभावी तरीका नहीं है

items.erase(std::remove_if(begin(items), end(items), [] (item*i) { 
    bool isActive = (*i)->update(); 
    if (!isActive) 
     return true; 

    other_code_involving(*i); 
    return false; 
}));