वेक्टर से आइटम निकाल रहा है, जबकि C ++ 11 रेंज में 'लूप' के लिए?

Question 1

मेरे पास IInventory * का वेक्टर है, और मैं प्रत्येक के साथ सामान करने के लिए C ++ 11 रेंज का उपयोग करके सूची के माध्यम से लूप कर रहा हूं।

एक के साथ कुछ सामान करने के बाद, मैं इसे सूची से निकालना और ऑब्जेक्ट को हटाना चाह सकता हूं। मुझे पता है कि मैं deleteइसे साफ करने के लिए किसी भी समय पॉइंटर पर कॉल कर सकता हूं , लेकिन रेंज forलूप में रहते हुए इसे वेक्टर से निकालने का उचित तरीका क्या है ? और अगर मैं इसे सूची से हटा दूं तो क्या मेरा लूप अमान्य हो जाएगा?

std::vector<IInventory*> inv;
inv.push_back(new Foo());
inv.push_back(new Bar());

for (IInventory* index : inv)
{
    // Do some stuff
    // OK, I decided I need to remove this object from 'inv'...
}

Question 2

नहीं, आप नहीं कर सकते। रेंज-आधारित forतब होता है जब आपको कंटेनर के प्रत्येक तत्व को एक बार एक्सेस करने की आवश्यकता होती है।

forयदि आपको कंटेनर को संशोधित करने की आवश्यकता है, तो आपको सामान्य लूप या उसके एक चचेरे भाई का उपयोग करना चाहिए , एक तत्व को एक से अधिक बार एक्सेस करें, या अन्यथा कंटेनर के माध्यम से गैर-रैखिक फैशन में पुनरावृति करें।

उदाहरण के लिए:

auto i = std::begin(inv);

while (i != std::end(inv)) {
    // Do some stuff
    if (blah)
        i = inv.erase(i);
    else
        ++i;
}

Question 3

हर बार जब कोई तत्व वेक्टर से हटा दिया जाता है, तो आपको पुनरावृत्त तत्व पर या उसके बाद पुनरावृत्तियों को मान लेना चाहिए, क्योंकि मिटाए गए तत्व को सफल करने वाले प्रत्येक तत्व को स्थानांतरित कर दिया जाता है।

रेंज के लिए एक लूप-आधारित, पुनरावृत्तियों का उपयोग करते हुए "सामान्य" लूप के लिए सिंटैक्टिक शुगर है, इसलिए उपरोक्त लागू होता है।

कहा जा रहा है, आप बस:

inv.erase(
    std::remove_if(
        inv.begin(),
        inv.end(),
        [](IInventory* element) -> bool {
            // Do "some stuff", then return true if element should be removed.
            return true;
        }
    ),
    inv.end()
);

Question 4

आपको आदर्श रूप से इस पर पुनरावृत्ति करते हुए वेक्टर को संशोधित नहीं करना चाहिए। मिटाए-हटाए मुहावरे का प्रयोग करें। यदि आप करते हैं, तो आप कुछ मुद्दों का सामना कर सकते हैं। चूंकि vectorएक eraseअमान्य में सभी पुनरावृत्तियों की शुरुआत तत्व के साथ होती है जो end()आपको मिटाए जाते हैं, इसलिए आपको यह सुनिश्चित करना होगा कि आपके पुनरावृत्तियों का उपयोग करके वैध बने रहें:

for (MyVector::iterator b = v.begin(); b != v.end();) { 
    if (foo) {
       b = v.erase( b ); // reseat iterator to a valid value post-erase
    else {
       ++b;
    }
}

ध्यान दें, कि आपको b != v.end()परीक्षण की आवश्यकता है। यदि आप इसे इस प्रकार से अनुकूलित करने का प्रयास करते हैं:

for (MyVector::iterator b = v.begin(), e = v.end(); b != e;)

eपहली eraseकॉल के बाद आपके द्वारा अमान्य किए जाने के बाद से आप UB में चलेंगे ।

Question 5

क्या उस पाश में रहते हुए तत्वों को निकालना एक सख्त आवश्यकता है? अन्यथा आप उन पॉइंटर्स को सेट कर सकते हैं जिन्हें आप NULL को हटाना चाहते हैं और सभी NULL पॉइंटर्स को हटाने के लिए वेक्टर के ऊपर एक और पास बनाते हैं।

std::vector<IInventory*> inv;
inv.push_back( new Foo() );
inv.push_back( new Bar() );

for ( IInventory* &index : inv )
{
    // do some stuff
    // ok I decided I need to remove this object from inv...?
    if (do_delete_index)
    {
        delete index;
        index = NULL;
    }
}
std::remove(inv.begin(), inv.end(), NULL);

Question 6

नेक्रोपोस्टिंग के लिए खेद है और यह भी खेद है कि अगर मेरी सी ++ विशेषज्ञता मेरे जवाब के तरीके से मिलती है, लेकिन यदि आप प्रत्येक आइटम के माध्यम से पुनरावृत्ति करने की कोशिश कर रहे हैं और संभव परिवर्तन (जैसे कि एक सूचकांक को मिटाना) कर रहे हैं, तो लूप के लिए बैकवर्ड का उपयोग करने का प्रयास करें।

for(int x=vector.getsize(); x>0; x--){

//do stuff
//erase index x

}

जब सूचकांक x मिटाते हैं, तो अगला लूप आइटम के लिए होगा "अंतिम चलना" के सामने। मुझे वाकई उम्मीद है कि इसने किसी की मदद की

Question 7

ठीक है, मुझे देर हो रही है, लेकिन वैसे भी: क्षमा करें, नहीं सही मैं अब तक क्या पढ़ा - यह है संभव है, तो आप सिर्फ दो iterators की जरूरत है:

std::vector<IInventory*>::iterator current = inv.begin();
for (IInventory* index : inv)
{
    if(/* ... */)
    {
        delete index;
    }
    else
    {
        *current++ = index;
    }
}
inv.erase(current, inv.end());

मूल्य को संशोधित करने के लिए एक पुनरावृत्ति अंक किसी अन्य पुनरावृत्ति को अमान्य नहीं करता है, इसलिए हम चिंता किए बिना ऐसा कर सकते हैं। दरअसल, std::remove_if(कम से कम जीसीसी कार्यान्वयन) कुछ ऐसा ही करता है (क्लासिक लूप का उपयोग करके ...), बस कुछ भी नहीं हटाता है और मिटाता नहीं है।

हालांकि, अवगत रहें कि यह थ्रेड सेफ नहीं है (!) - हालाँकि, यह ऊपर के कुछ अन्य समाधानों के लिए भी लागू होता है ...

Question 8

मैं उदाहरण के साथ दिखाऊंगा, नीचे दिए गए उदाहरण वेक्टर से विषम तत्वों को हटाते हैं:

void test_del_vector(){
    std::vector<int> vecInt{0, 1, 2, 3, 4, 5};

    //method 1
    for(auto it = vecInt.begin();it != vecInt.end();){
        if(*it % 2){// remove all the odds
            it = vecInt.erase(it);
        } else{
            ++it;
        }
    }

    // output all the remaining elements
    for(auto const& it:vecInt)std::cout<<it;
    std::cout<<std::endl;

    // recreate vecInt, and use method 2
    vecInt = {0, 1, 2, 3, 4, 5};
    //method 2
    for(auto it=std::begin(vecInt);it!=std::end(vecInt);){
        if (*it % 2){
            it = vecInt.erase(it);
        }else{
            ++it;
        }
    }

    // output all the remaining elements
    for(auto const& it:vecInt)std::cout<<it;
    std::cout<<std::endl;

    // recreate vecInt, and use method 3
    vecInt = {0, 1, 2, 3, 4, 5};
    //method 3
    vecInt.erase(std::remove_if(vecInt.begin(), vecInt.end(),
                 [](const int a){return a % 2;}),
                 vecInt.end());

    // output all the remaining elements
    for(auto const& it:vecInt)std::cout<<it;
    std::cout<<std::endl;

}

उत्पादन नीचे जगा:

024
024
024

ध्यान रखें, विधि eraseपारित पुनरावृत्ति के अगले पुनरावृत्ति लौटाएगी।

से यहाँ , तो हम अधिक उत्पन्न विधि का उपयोग कर सकते हैं:

template<class Container, class F>
void erase_where(Container& c, F&& f)
{
    c.erase(std::remove_if(c.begin(), c.end(),std::forward<F>(f)),
            c.end());
}

void test_del_vector(){
    std::vector<int> vecInt{0, 1, 2, 3, 4, 5};
    //method 4
    auto is_odd = [](int x){return x % 2;};
    erase_where(vecInt, is_odd);

    // output all the remaining elements
    for(auto const& it:vecInt)std::cout<<it;
    std::cout<<std::endl;    
}

उपयोग करने के तरीके को देखने के लिए यहां देखें std::remove_if। https://en.cppreference.com/w/cpp/algorithm/remove

Question 9

इस थ्रेड शीर्षक के विरोध में, मैं दो पास का उपयोग करूंगा:

#include <algorithm>
#include <vector>

std::vector<IInventory*> inv;
inv.push_back(new Foo());
inv.push_back(new Bar());

std::vector<IInventory*> toDelete;

for (IInventory* index : inv)
{
    // Do some stuff
    if (deleteConditionTrue)
    {
        toDelete.push_back(index);
    }
}

for (IInventory* index : toDelete)
{
    inv.erase(std::remove(inv.begin(), inv.end(), index), inv.end());
}

Question 10

स्विच करने के लिए एक बहुत अधिक सुरुचिपूर्ण समाधान होगा std::list(यह मानते हुए कि आपको तेज यादृच्छिक अभिगम की आवश्यकता नहीं है)।

list<Widget*> widgets ; // create and use this..

फिर आप .remove_ifएक पंक्ति में C ++ फ़ंक्टर के साथ हटा सकते हैं :

widgets.remove_if( []( Widget*w ){ return w->isExpired() ; } ) ;

इसलिए यहाँ मैं एक फ़नकार लिख रहा हूँ जो एक तर्क ( Widget*) को स्वीकार करता है । वापसी मूल्य वह शर्त है जिस पर Widget*सूची से हटाया जाना है।

मुझे यह वाक्यविन्यास तालमेल लगता है। मुझे नहीं लगता कि मैं कभी भी std :: vectors केremove_if लिए उपयोग करूँगा - वहाँ बहुत कुछ है और शोर है कि आप शायद पूर्णांक-इंडेक्स-आधारित डिलीट का उपयोग करके बेहतर हैं या केवल एक पुराने पुराने नियमित रूप से चलने वाले-आधारित डिलीट (जैसा दिखाया गया है) नीचे)। लेकिन आपको वास्तव में बहुत अधिक के बीच से नहीं निकालना चाहिए , इसलिए सूची के विलोपन के बीच के इस मामले के लिए स्विच करने की सलाह दी जाती है।inv.begin()inv.end()std::vectorlist

नोट हालांकि मैं फोन करने के लिए एक मौका नहीं मिला deleteपर Widget*की है कि हटा दिया गया। ऐसा करने के लिए, यह इस तरह दिखेगा:

widgets.remove_if( []( Widget*w ){
  bool exp = w->isExpired() ;
  if( exp )  delete w ;       // delete the widget if it was expired
  return exp ;                // remove from widgets list if it was expired
} ) ;

तुम भी एक नियमित itter- आधारित लूप का उपयोग कर सकते हैं जैसे:

//                                                              NO INCREMENT v
for( list<Widget*>::iterator iter = widgets.begin() ; iter != widgets.end() ; )
{
  if( (*iter)->isExpired() )
  {
    delete( *iter ) ;
    iter = widgets.erase( iter ) ; // _advances_ iter, so this loop is not infinite
  }
  else
    ++iter ;
}

यदि आप की लंबाई पसंद नहीं है for( list<Widget*>::iterator iter = widgets.begin() ; ..., तो आप उपयोग कर सकते हैं

for( auto iter = widgets.begin() ; ...

Question 11

मुझे लगता है कि मैं निम्नलिखित करूँगा ...

for (auto itr = inv.begin(); itr != inv.end();)
{
   // Do some stuff
   if (OK, I decided I need to remove this object from 'inv')
      itr = inv.erase(itr);
   else
      ++itr;
}

Question 12

आप लूप पुनरावृत्ति के दौरान पुनरावृत्ति को हटा नहीं सकते क्योंकि इट्रेटर गणना बेमेल हो जाती है और कुछ पुनरावृत्ति के बाद आपके पास अमान्य पुनरावृत्ति होगा।

समाधान: 1) मूल वेक्टर 2 की प्रतिलिपि लें) इस प्रतिलिपि का उपयोग करके पुनरावृत्त को पुनरावृत्त करें 2) कुछ सामान करें और इसे मूल वेक्टर से हटा दें।

std::vector<IInventory*> inv;
inv.push_back(new Foo());
inv.push_back(new Bar());

std::vector<IInventory*> copyinv = inv;
iteratorCout = 0;
for (IInventory* index : copyinv)
{
    // Do some stuff
    // OK, I decided I need to remove this object from 'inv'...
    inv.erase(inv.begin() + iteratorCout);
    iteratorCout++;
}

Question 13

एक-एक करके मिटा देने वाला तत्व आसानी से N ^ 2 प्रदर्शन की ओर ले जाता है। उन तत्वों को चिह्नित करने के लिए बेहतर है जिन्हें लूप के बाद एक बार में मिटा दिया जाना चाहिए और मिटा देना चाहिए। अगर मैं आपके वेक्टर में मान्य तत्व नहीं है, तो nullptr मान सकते हैं

std::vector<IInventory*> inv;
// ... push some elements to inv
for (IInventory*& index : inv)
{
    // Do some stuff
    // OK, I decided I need to remove this object from 'inv'...
    {
      delete index;
      index =nullptr;
    }
}
inv.erase( std::remove( begin( inv ), end( inv ), nullptr ), end( inv ) );

कार्य करना चाहिए।

यदि आपका "कुछ सामान करो" वेक्टर के तत्वों को नहीं बदल रहा है और केवल तत्व को हटाने या रखने का निर्णय लेने के लिए उपयोग किया जाता है, तो आप इसे लैम्ब्डा में बदल सकते हैं (जैसा कि किसी के पहले पोस्ट में सुझाया गया था) और उपयोग करें

inv.erase( std::remove_if( begin( inv ), end( inv ), []( Inventory* i )
  {
    // DO some stuff
    return OK, I decided I need to remove this object from 'inv'...
  } ), end( inv ) );