Removendo item do vetor, enquanto no intervalo 'for' do C ++ 11?

Tenho um vetor de IInventory * e estou percorrendo a lista usando o intervalo C ++ 11 para, para fazer coisas com cada um.

Depois de fazer algumas coisas com um, posso querer removê-lo da lista e excluir o objeto. Sei que posso chamar deleteo ponteiro a qualquer momento para limpá-lo, mas qual é a maneira correta de removê-lo do vetor, enquanto está no forloop de intervalo ? E se eu removê-lo da lista, meu loop será invalidado?

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

Não, você não pode. Baseado em intervalo foré para quando você precisa acessar cada elemento de um contêiner uma vez.

Você deve usar o forloop normal ou um de seus primos se precisar modificar o contêiner à medida que avança, acessar um elemento mais de uma vez ou, de outra forma, iterar de forma não linear por meio do contêiner.

Por exemplo:

auto i = std::begin(inv);

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

Cada vez que um elemento é removido do vetor, você deve assumir que os iteradores no momento ou após o elemento apagado não são mais válidos, porque cada um dos elementos que sucedem o elemento apagado são movidos.

Um for-loop baseado em intervalo é apenas açúcar sintático para loop "normal" usando iteradores, portanto, o acima se aplica.

Dito isso, você pode simplesmente:

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

Idealmente, você não deve modificar o vetor durante a iteração sobre ele. Use o idioma apagar-remover. Se você fizer isso, provavelmente encontrará alguns problemas. Como em um vectoran eraseinvalida todos os iteradores começando com o elemento sendo apagado até o, end()você precisará se certificar de que seus iteradores permanecem válidos usando:

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

Observe que você precisa do b != v.end()teste no estado em que se encontra. Se você tentar otimizá-lo da seguinte maneira:

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

você irá se deparar com UB, pois seu eé invalidado após a primeira erasechamada.

É um requisito estrito remover elementos durante esse loop? Caso contrário, você pode definir os ponteiros que deseja excluir como NULL e fazer outra passagem sobre o vetor para remover todos os ponteiros 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);

desculpe por necroposting e também desculpe se minha experiência em c ++ atrapalhar minha resposta, mas se você tentar iterar por cada item e fazer alterações possíveis (como apagar um índice), tente usar um backwords para loop.

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

//do stuff
//erase index x

}

ao apagar o índice x, o próximo loop será para o item "na frente" da última iteração. eu realmente espero que isso ajude alguém

OK, estou atrasado, mas de qualquer maneira: Desculpe, não corrija o que li até agora - é possível, você só precisa de dois iteradores:

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

Apenas modificar o valor para o qual um iterador aponta não invalida nenhum outro iterador, portanto, podemos fazer isso sem ter que nos preocupar. Na verdade, std::remove_if(implementação gcc pelo menos) faz algo muito semelhante (usando um loop clássico ...), apenas não exclui nada e não apaga.

Esteja ciente, no entanto, que isso não é seguro para thread (!) - no entanto, isso também se aplica a algumas das outras soluções acima ...

Vou mostrar com um exemplo, o exemplo abaixo remove elementos estranhos do vetor:

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;

}

saída aw abaixo:

024
024
024

Lembre-se de que o método eraseretornará o próximo iterador do iterador passado.

A partir daqui , podemos usar um método mais gerador:

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

Veja aqui para ver como usar std::remove_if . https://en.cppreference.com/w/cpp/algorithm/remove

Em oposição a este título de tópicos, eu usaria dois passes:

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

Uma solução muito mais elegante seria mudar para std::list(assumindo que você não precisa de acesso aleatório rápido).

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

Você pode então excluir com .remove_ifum functor C ++ em uma linha:

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

Então, aqui estou apenas escrevendo um functor que aceita um argumento (o Widget*). O valor de retorno é a condição na qual remover um Widget*da lista.

Acho essa sintaxe palatável. Eu não acho que eu nunca usaria remove_ifpara std :: vetores - há muito inv.begin()e inv.end()barulho lá você é provavelmente melhor fora de usar uma base-integer-índice de exclusão ou apenas uma planície antiga regular de exclusão (como mostrado à base de iterador abaixo). Mas você não deve realmente remover do meio de umstd::vector qualquer maneira, então listé aconselhável mudar para um neste caso de exclusão frequente no meio da lista.

Observe, entretanto, que não tive a chance de ligar deletepara os Widget*que foram removidos. Para fazer isso, ficaria assim:

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

Você também pode usar um loop baseado em iterador regular como:

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

Se você não gosta do comprimento de for( list<Widget*>::iterator iter = widgets.begin() ; ..., você pode usar

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

Acho que faria o seguinte ...

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

você não pode excluir o iterador durante a iteração do loop porque a contagem do iterador não corresponde e, após alguma iteração, você teria um iterador inválido.

Solução: 1) pegar a cópia do vetor original 2) iterar o iterador usando esta cópia 2) fazer algumas coisas e excluí-lo do vetor original.

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

Apagar um elemento por um leva facilmente ao desempenho do N ^ 2. Melhor marcar os elementos que devem ser apagados e apagá-los imediatamente após o loop. Se eu posso presumir nullptr em um elemento inválido em seu vetor, então

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

Deveria trabalhar.

Caso o seu "Faça alguma coisa" não esteja mudando elementos do vetor e apenas seja usado para tomar a decisão de remover ou manter o elemento, você pode convertê-lo para lambda (como foi sugerido em um post anterior de alguém) e usar

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