Usuwanie elementu z wektora, podczas gdy w C ++ 11 pętla „for”?

Mam wektor IInventory * i przeglądam listę przy użyciu zakresu C ++ 11 dla, aby robić rzeczy z każdym z nich.

Po zrobieniu kilku rzeczy z jednym, mogę chcieć usunąć go z listy i usunąć obiekt. Wiem, że mogę deletew każdej chwili wywołać wskaźnik, aby go wyczyścić, ale jaki jest właściwy sposób usunięcia go z wektora, gdy jestem w forpętli zakresu ? A jeśli usunę go z listy, czy moja pętla zostanie unieważniona?

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'...
}

Nie, nie możesz. Oparty na zakresie forjest używany, gdy musisz raz uzyskać dostęp do każdego elementu kontenera.

Powinieneś użyć normalnej forpętli lub jednego z jej kuzynów, jeśli musisz zmodyfikować kontener w trakcie, uzyskać dostęp do elementu więcej niż jeden raz lub w inny sposób iterować w nieliniowy sposób przez kontener.

Na przykład:

auto i = std::begin(inv);

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

Za każdym razem, gdy element jest usuwany z wektora, należy założyć, że iteratory na lub po usuniętym elemencie nie są już prawidłowe, ponieważ każdy z elementów występujących po usuniętym elemencie jest przesuwany.

Oparta na zakresie pętla for jest po prostu cukrem syntaktycznym dla „normalnej” pętli używającej iteratorów, więc powyższe ma zastosowanie.

Biorąc to pod uwagę, możesz po prostu:

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()
);

Idealnie nie powinieneś modyfikować wektora podczas iteracji po nim. Użyj idiomu erase-remove. Jeśli to zrobisz, prawdopodobnie napotkasz kilka problemów. Ponieważ w vectoran eraseunieważnia wszystkie iteratory począwszy od elementu są usuwane upto end()trzeba upewnić się, że Iteratory zachowują ważność za pomocą:

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;
    }
}

Zauważ, że potrzebujesz b != v.end()testu tak jak jest. Jeśli spróbujesz go zoptymalizować w następujący sposób:

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

natkniesz się na UB, ponieważ Twój ejest unieważniony po pierwszym erasewywołaniu.

Czy usuwanie elementów w tej pętli jest ścisłym wymogiem? W przeciwnym razie możesz ustawić wskaźniki, które chcesz usunąć, na NULL i wykonać kolejny przejazd nad wektorem, aby usunąć wszystkie wskaźniki 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);

przepraszam za nekropostowanie i również przepraszam, jeśli moja wiedza na temat c ++ przeszkadza mi w udzieleniu odpowiedzi, ale jeśli próbujesz iterować przez każdy element i wprowadzać możliwe zmiany (takie jak wymazanie indeksu), spróbuj użyć backwords for loop.

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

//do stuff
//erase index x

}

podczas kasowania indeksu x następna pętla będzie dotyczyła elementu znajdującego się „przed” ostatnią iteracją. Naprawdę mam nadzieję, że to komuś pomogło

OK, spóźniłem się, ale i tak: przepraszam, nie poprawiam tego, co przeczytałem do tej pory - jest możliwe, potrzebujesz tylko dwóch iteratorów:

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

Samo zmodyfikowanie wartości, na którą wskazuje iterator, nie unieważni żadnego innego iteratora, więc możemy to zrobić bez obaw. Tak właściwie,std::remove_if (przynajmniej implementacja gcc) robi coś bardzo podobnego (używając klasycznej pętli ...), po prostu niczego nie usuwa i nie kasuje.

Należy jednak pamiętać, że nie jest to bezpieczne wątkowo (!) - dotyczy to jednak również niektórych innych rozwiązań powyżej ...

Pokażę na przykładzie, poniższy przykład usuwa nieparzyste elementy z wektora:

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;

}

wyjście aw poniżej:

024
024
024

Należy pamiętać, że metoda erasezwróci następny iterator przekazanego iteratora.

Od tutaj możemy zastosować metodę bardziej generowania:

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;    
}

Zobacz tutaj, aby zobaczyć, jak używać std::remove_if. https://en.cppreference.com/w/cpp/algorithm/remove

W przeciwieństwie do tego tytułu wątków użyłbym dwóch przejść:

#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());
}

O wiele bardziej eleganckim rozwiązaniem byłoby przejście na std::list(zakładając, że nie potrzebujesz szybkiego losowego dostępu).

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

Następnie możesz usunąć za pomocą .remove_ifi funktora C ++ w jednej linii:

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

Więc tutaj piszę po prostu funktor, który akceptuje jeden argument (the Widget*). Wartość zwracana to warunek, w którym należy usunąć Widget*z listy.

Uważam, że ta składnia jest do przyjęcia. Nie sądzę, abym kiedykolwiek używał remove_ifdla std :: vectors - jest tam tak dużo inv.begin()i inv.end()szumu, że prawdopodobnie lepiej będzie użyć usuwania opartego na indeksach całkowitych lub po prostu zwykłego starego regularnego usuwania opartego na iteratorze (jak pokazano poniżej). Ale tak naprawdę nie powinieneś usuwać z połowy std::vectorbardzo dużo, więc listzaleca się przełączenie na a w tym przypadku częstego usuwania środka listy.

Zauważ jednak, że nie miałem szansy zadzwonić deletena te Widget*, które zostały usunięte. Aby to zrobić, wyglądałoby to tak:

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
} ) ;

Możesz także użyć zwykłej pętli opartej na iteratorze, na przykład:

//                                                              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 ;
}

Jeśli nie podoba Ci się długość for( list<Widget*>::iterator iter = widgets.begin() ; ..., możesz użyć

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

Myślę, że zrobiłbym co następuje ...

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;
}

nie możesz usunąć iteratora podczas iteracji pętli, ponieważ liczba iteratorów jest niedopasowana i po pewnej iteracji miałbyś nieprawidłowy iterator.

Rozwiązanie: 1) weź kopię oryginalnego wektora 2) przeprowadź iterację iteratora używając tej kopii 2) zrób coś i usuń go z oryginalnego wektora.

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++;
}  

Wymazywanie elementu jeden po drugim łatwo prowadzi do wydajności N ^ 2. Lepiej jest zaznaczyć elementy, które powinny zostać usunięte i usunąć je od razu po wykonaniu pętli. Jeśli mogę założyć, że nullptr jest nieprawidłowym elementem w twoim wektorze, to

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 ) ); 

powinno działać.

W przypadku, gdy twoje "Zrób coś" nie zmienia elementów wektora i służy tylko do podjęcia decyzji o usunięciu lub zachowaniu elementu, możesz przekonwertować go na lambdę (jak zasugerowano we wcześniejszym poście) i użyć

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 ) );