Rimuovere l'elemento dal vettore, mentre nel ciclo C ++ 11 range 'for'?

Ho un vettore di IInventory * e sto scorrendo l'elenco usando l'intervallo C ++ 11 per, per fare cose con ciascuno.

Dopo aver eseguito alcune operazioni con uno, è possibile rimuoverlo dall'elenco ed eliminare l'oggetto. So di poter chiamare deleteil puntatore in qualsiasi momento per ripulirlo, ma qual è il modo corretto per rimuoverlo dal vettore, mentre si è nel forciclo di intervallo ? E se lo rimuovo dall'elenco il mio ciclo verrà invalidato?

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

No, non puoi. Basato su intervallo forè per quando è necessario accedere una volta a ogni elemento di un contenitore.

Dovresti usare il forciclo normale o uno dei suoi cugini se hai bisogno di modificare il contenitore mentre procedi, accedere a un elemento più di una volta o comunque iterare in modo non lineare attraverso il contenitore.

Per esempio:

auto i = std::begin(inv);

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

Ogni volta che un elemento viene rimosso dal vettore, è necessario presumere che gli iteratori in corrispondenza o dopo l'elemento cancellato non siano più validi, poiché ciascuno degli elementi successivi all'elemento cancellato viene spostato.

Un ciclo for basato su intervalli è solo zucchero sintattico per un ciclo "normale" che utilizza gli iteratori, quindi si applica quanto sopra.

Detto questo, potresti semplicemente:

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 non dovresti modificare il vettore durante l'iterazione su di esso. Usa l'idioma cancella-rimuovi. In tal caso, è probabile che si verifichino alcuni problemi. Dal momento che in un vectorun eraseinvalida tutti iteratori che inizia con l'elemento venga cancellato fino alla end()dovrai fare in modo che i vostri iteratori restano valide tramite:

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

Nota che hai bisogno del b != v.end()test così com'è. Se provi a ottimizzarlo come segue:

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

ti imbatterai in UB poiché il tuo eviene invalidato dopo la prima erasechiamata.

È un requisito rigoroso rimuovere gli elementi mentre si è in quel ciclo? Altrimenti potresti impostare i puntatori che vuoi eliminare su NULL e fare un altro passaggio sul vettore per rimuovere tutti i puntatori 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);

scusa per il necropost e anche se la mia esperienza in C ++ ostacola la mia risposta, ma se stai cercando di iterare ogni elemento e apportare possibili modifiche (come cancellare un indice), prova a utilizzare un ciclo for backwords.

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

//do stuff
//erase index x

}

quando si cancella l'indice x, il ciclo successivo sarà per l'elemento "davanti" all'ultima iterazione. spero davvero che questo abbia aiutato qualcuno

OK, sono in ritardo, ma comunque: scusa, non ho corretto quello che ho letto finora - è possibile, bastano due iteratori:

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

La semplice modifica del valore a cui punta un iteratore non invalida nessun altro iteratore, quindi possiamo farlo senza doversi preoccupare. In realtà,std::remove_if (almeno l'implementazione di gcc) fa qualcosa di molto simile (usando un ciclo classico ...), semplicemente non cancella nulla e non cancella.

Tieni presente, tuttavia, che questo non è thread-safe (!) - Tuttavia, questo vale anche per alcune delle altre soluzioni sopra ...

Mostrerò con l'esempio, l'esempio seguente rimuove gli elementi dispari dal vettore:

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;

}

output aw di seguito:

024
024
024

Tieni presente che il metodo eraserestituirà l'iteratore successivo dell'iteratore passato.

Da qui , possiamo utilizzare un metodo più di generazione:

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

Vedi qui per vedere come usare std::remove_if. https://en.cppreference.com/w/cpp/algorithm/remove

In opposizione al titolo di questo thread, userei due passaggi:

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

Una soluzione molto più elegante sarebbe passare a std::list(supponendo che non sia necessario un accesso casuale veloce).

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

È quindi possibile eliminare con .remove_ife un funtore C ++ in una riga:

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

Quindi qui sto solo scrivendo un funtore che accetta un argomento (il Widget*). Il valore restituito è la condizione in base alla quale rimuovere a Widget*dall'elenco.

Trovo questa sintassi appetibile. Non penso che utilizzerei mai remove_ifper std :: vectors - c'è così tanto inv.begin()e inv.end()rumore lì probabilmente è meglio usare un'eliminazione basata su indice intero o semplicemente una normale eliminazione basata su iteratore regolare (come mostrato sotto). Ma in ogni caso non dovresti rimuovere molto dal centro di un file std::vector, quindi passare a un filelist per questo caso di eliminazione frequente di metà elenco.

Nota, tuttavia, non ho avuto la possibilità di chiamare deletequelli Widget*che sono stati rimossi. Per farlo, sarebbe simile a questo:

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

Puoi anche usare un normale ciclo basato su iteratore in questo modo:

//                                                              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 non ti piace la lunghezza di for( list<Widget*>::iterator iter = widgets.begin() ; ..., puoi usare

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

Penso che farei quanto segue ...

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

non puoi eliminare l'iteratore durante l'iterazione del ciclo perché il conteggio dell'iteratore non corrisponde e dopo qualche iterazione avresti un iteratore non valido.

Soluzione: 1) prendi la copia del vettore originale 2) itera l'iteratore usando questa copia 2) fai alcune cose ed eliminalo dal vettore originale.

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

La cancellazione di un elemento uno per uno porta facilmente a prestazioni N ^ 2. Meglio contrassegnare gli elementi che dovrebbero essere cancellati e cancellarli subito dopo il ciclo. Se posso presumere nullptr in un elemento non valido nel tuo vettore, allora

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

dovrebbe funzionare.

Nel caso in cui "Fai qualcosa" non stia cambiando elementi del vettore e viene utilizzato solo per prendere la decisione di rimuovere o mantenere l'elemento, puoi convertirlo in lambda (come è stato suggerito in un post precedente di qualcuno) e utilizzare

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