C ++ 11 'for' döngüsünde iken vektörden öğe kaldırılıyor mu?

Bir IInventory * vektörüne sahibim ve her biriyle bir şeyler yapmak için C ++ 11 aralığını kullanarak listede dönüyorum.

Biriyle bazı şeyler yaptıktan sonra, onu listeden çıkarmak ve nesneyi silmek isteyebilirim. deleteİşaretçiyi temizlemek için istediğim zaman çağırabileceğimi biliyorum , ancak aralık fordöngüsündeyken onu vektörden kaldırmanın doğru yolu nedir? Ve onu listeden çıkarırsam döngüm geçersiz olur mu?

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

Hayır, yapamazsınız. Menzile dayalı for, bir kabın her öğesine bir kez erişmeniz gerektiğinde kullanılır.

forKabı ilerledikçe değiştirmeniz, bir öğeye birden fazla kez erişmeniz veya kapsayıcı aracılığıyla doğrusal olmayan bir şekilde yineleme yapmanız gerekirse , normal döngüyü veya kuzenlerinden birini kullanmalısınız .

Örneğin:

auto i = std::begin(inv);

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

Bir öğe vektörden her kaldırıldığında, silinen öğenin ardından gelen öğelerin her biri taşındığından, silinen öğedeki veya sonraki yineleyicilerin artık geçerli olmadığını varsaymalısınız.

Aralık tabanlı bir for-döngüsü, yineleyiciler kullanan "normal" döngü için sözdizimsel şekerdir, bu nedenle yukarıdakiler geçerlidir.

Bununla birlikte, basitçe şunları yapabilirsiniz:

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

İdeal olarak, üzerinde yinelerken vektörü değiştirmemelisiniz. Sil-kaldır deyimini kullanın. Eğer yaparsanız, birkaç sorunla karşılaşmanız olasıdır. Bir de yana vectorbir erasegeçersiz tüm yineleyiciler elemanı ile başlayan kadar silinmeye end()Eğer kullanarak yineleyiciler geçerli kalmasını sağlamak gerekir:

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()Teste olduğu gibi ihtiyacınız olduğunu unutmayın . Aşağıdaki gibi optimize etmeye çalışırsanız:

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

eİlk erasearamadan sonra geçersiz kılındığınız için UB ile karşılaşacaksınız .

Bu döngüde öğeleri kaldırmak kesin bir gereklilik mi? Aksi takdirde, silmek istediğiniz işaretçileri NULL olarak ayarlayabilir ve tüm NULL işaretçileri kaldırmak için vektör üzerinden başka bir geçiş yapabilirsiniz.

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

necroposting için özür dilerim ve ayrıca c ++ uzmanlığım cevabımın önüne geçerse özür dilerim, ancak her öğeyi yinelemeye ve olası değişiklikleri yapmaya (bir dizini silmek gibi) çalışıyorsanız, döngü için bir backwords kullanmayı deneyin.

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

//do stuff
//erase index x

}

x dizinini silerken, sonraki döngü son yinelemenin "önündeki" öğe için olacaktır. Umarım bu birine yardım eder

Tamam, ben yine geç kaldım ama: Üzgünüm, doğru ana kadar okuduklarım - bu ise mümkün, sadece iki yineleyiciler gerekir:

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

Sadece bir yineleyicinin işaret ettiği değeri değiştirmek, başka hiçbir yineleyiciyi geçersiz kılmaz, bu yüzden bunu endişelenmeden yapabiliriz. Aslında, std::remove_if(en azından gcc uygulaması) çok benzer bir şey yapar (klasik bir döngü kullanarak ...), sadece hiçbir şeyi silmez ve silmez.

Bununla birlikte, bunun iş parçacığı açısından güvenli olmadığını unutmayın (!) - ancak bu, yukarıdaki diğer çözümlerin bazıları için de geçerlidir ...

Örnekle göstereceğim, aşağıdaki örnek vektörden tuhaf öğeleri kaldırır:

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;

}

aşağıdaki aw çıkışı:

024
024
024

Unutmayın, yöntem erase, geçen yineleyicinin bir sonraki yineleyicisini döndürecektir.

Dan burada , biz daha oluşturmak yöntemini kullanabilirsiniz:

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

Nasıl kullanılacağını görmek için buraya bakın std::remove_if. https://en.cppreference.com/w/cpp/algorithm/remove

Bu konu başlığının aksine, iki geçiş kullanırım:

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

Çok daha zarif bir çözüm, geçiş yapmak olacaktır std::list(hızlı rastgele erişime ihtiyacınız olmadığını varsayarak).

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

Daha sonra .remove_iftek satırda bir C ++ functor ile silebilirsiniz :

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

Yani burada sadece bir argümanı (the Widget*) kabul eden bir functor yazıyorum . Dönüş değeri, a'nın Widget*listeden kaldırılacağı koşuldur .

Bu sözdizimini lezzetli buluyorum. Ben hiç kullanmak sanmıyorum remove_ifiçin std :: vektörler - orada çok olduğunu inv.begin()ve inv.end()gürültü kullandığınız muhtemelen daha çok işinize bir tamsayı-dizin tabanlı silme ya da sadece düz normal eski yineleyici tabanlı gösterildiği gibi (silme altında). Ancak std::vectoryine de ortasından çok fazla uzaklaşmamalısınız , bu nedenle listbu durum için listenin ortasının sık sık silinmesi için a'ya geçilmesi önerilir.

Ancak , kaldırılanları arama şansım olmadığına deletedikkat edin Widget*. Bunu yapmak için şöyle görünecektir:

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

Bunun gibi düzenli yineleyici tabanlı bir döngü de kullanabilirsiniz:

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

Uzunluğunu beğenmediyseniz for( list<Widget*>::iterator iter = widgets.begin() ; ...kullanabilirsiniz

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

Sanırım şunu yapardım ...

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

döngü yinelemesi sırasında yineleyiciyi silemezsiniz çünkü yineleyici sayısı uyumsuz olur ve bazı yinelemelerden sonra geçersiz yineleyiciniz olur.

Çözüm: 1) orijinal vektörün kopyasını alın 2) bu kopyayı kullanarak yineleyiciyi yineleyin 2) bazı şeyler yapın ve orijinal vektörden silin.

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

Öğeyi tek tek silmek, kolayca N ^ 2 performansına yol açar. Silinmesi gereken öğeleri işaretlemek ve döngüden sonra hemen silmek daha iyidir. Vektörünüzde nullptr'nin geçerli olmadığını varsayabilirsem, o zaman

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

çalışmalı.

"Bir şeyler yapın", vektörün öğelerini değiştirmiyorsa ve yalnızca öğeyi kaldırmak veya tutmak için karar vermek için kullanılıyorsa, onu lambda'ya dönüştürebilir (birinin önceki gönderisinde önerildiği gibi) ve

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