¿Puedes eliminar elementos de una lista std :: mientras iteras por ella?

Tengo un código que se ve así:

for (std::list<item*>::iterator i=items.begin();i!=items.end();i++)
{
    bool isActive = (*i)->update();
    //if (!isActive) 
    //  items.remove(*i); 
    //else
       other_code_involving(*i);
}
items.remove_if(CheckItemNotActive);

Me gustaría eliminar los elementos inactivos inmediatamente después de actualizarlos, para evitar volver a recorrer la lista. Pero si agrego las líneas comentadas, aparece un error cuando llego a i++: "El iterador de lista no se puede incrementar". Intenté algunas alternativas que no aumentaron en la declaración for, pero no pude hacer que nada funcionara.

¿Cuál es la mejor manera de eliminar elementos mientras recorres una lista estándar?

Primero debe incrementar el iterador (con i ++) y luego eliminar el elemento anterior (por ejemplo, utilizando el valor devuelto de i ++). Puede cambiar el código a un ciclo while de esta manera:

std::list<item*>::iterator i = items.begin();
while (i != items.end())
{
    bool isActive = (*i)->update();
    if (!isActive)
    {
        items.erase(i++);  // alternatively, i = items.erase(i);
    }
    else
    {
        other_code_involving(*i);
        ++i;
    }
}

Quieres hacer:

i= items.erase(i);

Eso actualizará correctamente el iterador para que apunte a la ubicación después del iterador que eliminó.

Debe hacer la combinación de la respuesta de Kristo y MSN:

// Note: Using the pre-increment operator is preferred for iterators because
//       there can be a performance gain.
//
// Note: As long as you are iterating from beginning to end, without inserting
//       along the way you can safely save end once; otherwise get it at the
//       top of each loop.

std::list< item * >::iterator iter = items.begin();
std::list< item * >::iterator end  = items.end();

while (iter != end)
{
    item * pItem = *iter;

    if (pItem->update() == true)
    {
        other_code_involving(pItem);
        ++iter;
    }
    else
    {
        // BTW, who is deleting pItem, a.k.a. (*iter)?
        iter = items.erase(iter);
    }
}

Por supuesto, lo más eficiente y más inteligente de SuperCool® STL sería algo como esto:

// This implementation of update executes other_code_involving(Item *) if
// this instance needs updating.
//
// This method returns true if this still needs future updates.
//
bool Item::update(void)
{
    if (m_needsUpdates == true)
    {
        m_needsUpdates = other_code_involving(this);
    }

    return (m_needsUpdates);
}

// This call does everything the previous loop did!!! (Including the fact
// that it isn't deleting the items that are erased!)
items.remove_if(std::not1(std::mem_fun(&Item::update)));

Utilice el algoritmo std :: remove_if.

Editar: El trabajo con colecciones debe ser como: 1. preparar la colección. 2. proceso de recogida.

La vida será más fácil si no mezclas estos pasos.

1. std :: remove_if. o list :: remove_if (si sabe que trabaja con list y no con TCollection)
2. std :: for_each

Aquí hay un ejemplo usando un forbucle que itera la lista e incrementa o revalida el iterador en caso de que un elemento sea eliminado durante el recorrido de la lista.

for(auto i = items.begin(); i != items.end();)
{
    if(bool isActive = (*i)->update())
    {
        other_code_involving(*i);
        ++i;

    }
    else
    {
        i = items.erase(i);

    }

}

items.remove_if(CheckItemNotActive);

La alternativa para la versión en bucle a la respuesta de Kristo.

Pierde algo de eficiencia, retrocede y luego avanza nuevamente al eliminar, pero a cambio del incremento de iterador adicional, puede hacer que el iterador se declare en el alcance del bucle y que el código se vea un poco más limpio. Qué elegir depende de las prioridades del momento.

La respuesta fue totalmente fuera de tiempo, lo sé ...

typedef std::list<item*>::iterator item_iterator;

for(item_iterator i = items.begin(); i != items.end(); ++i)
{
    bool isActive = (*i)->update();

    if (!isActive)
    {
        items.erase(i--); 
    }
    else
    {
        other_code_involving(*i);
    }
}

Lo resumí, aquí está el método tres con ejemplo:

1. usando el whilebucle

list<int> lst{4, 1, 2, 3, 5};

auto it = lst.begin();
while (it != lst.end()){
    if((*it % 2) == 1){
        it = lst.erase(it);// erase and go to next
    } else{
        ++it;  // go to next
    }
}

for(auto it:lst)cout<<it<<" ";
cout<<endl;  //4 2

2. usando la remove_iffunción miembro en la lista:

list<int> lst{4, 1, 2, 3, 5};

lst.remove_if([](int a){return a % 2 == 1;});

for(auto it:lst)cout<<it<<" ";
cout<<endl;  //4 2

3. usando la std::remove_iffunción que combina con la erasefunción miembro:

list<int> lst{4, 1, 2, 3, 5};

lst.erase(std::remove_if(lst.begin(), lst.end(), [](int a){
    return a % 2 == 1;
}), lst.end());

for(auto it:lst)cout<<it<<" ";
cout<<endl;  //4 2

4. usando el forbucle, debería tener en cuenta actualizar el iterador:

list<int> lst{4, 1, 2, 3, 5};

for(auto it = lst.begin(); it != lst.end();++it){
    if ((*it % 2) == 1){
        it = lst.erase(it);  erase and go to next(erase will return the next iterator)
        --it;  // as it will be add again in for, so we go back one step
    }
}

for(auto it:lst)cout<<it<<" ";
cout<<endl;  //4 2 

La eliminación invalida solo los iteradores que apuntan a los elementos que se eliminan.

Entonces, en este caso, después de eliminar * i, se invalida y no puede hacer un incremento en él.

Lo que puede hacer es primero guardar el iterador del elemento que se va a eliminar, luego incrementar el iterador y luego eliminar el guardado.

Si piensa en std::listuna cola, puede quitar y poner en cola todos los elementos que desea conservar, pero solo quitar (y no poner en cola) el elemento que desea eliminar. Aquí hay un ejemplo donde quiero eliminar 5 de una lista que contiene los números 1-10 ...

std::list<int> myList;

int size = myList.size(); // The size needs to be saved to iterate through the whole thing

for (int i = 0; i < size; ++i)
{
    int val = myList.back()
    myList.pop_back() // dequeue
    if (val != 5)
    {
         myList.push_front(val) // enqueue if not 5
    }
}

myList ahora solo tendrá los números 1-4 y 6-10.

Iterar hacia atrás evita el efecto de borrar un elemento en los elementos restantes a atravesar:

typedef list<item*> list_t;
for ( list_t::iterator it = items.end() ; it != items.begin() ; ) {
    --it;
    bool remove = <determine whether to remove>
    if ( remove ) {
        items.erase( it );
    }
}

PD: vea esto , por ejemplo, con respecto a la iteración hacia atrás.

PS2: no probé a fondo si maneja bien los elementos de borrado en los extremos.

Puedes escribir

std::list<item*>::iterator i = items.begin();
while (i != items.end())
{
    bool isActive = (*i)->update();
    if (!isActive) {
        i = items.erase(i); 
    } else {
        other_code_involving(*i);
        i++;
    }
}

Puede escribir código equivalente con std::list::remove_if, que es menos detallado y más explícito

items.remove_if([] (item*i) {
    bool isActive = (*i)->update();
    if (!isActive) 
        return true;

    other_code_involving(*i);
    return false;
});

El std::vector::erase std::remove_ifidioma debe usarse cuando los elementos son un vector en lugar de una lista para mantener la competencia en O (n), o en caso de que escriba un código genérico y los elementos podrían ser un contenedor sin una forma efectiva de borrar elementos individuales (como un vector)

items.erase(std::remove_if(begin(items), end(items), [] (item*i) {
    bool isActive = (*i)->update();
    if (!isActive) 
        return true;

    other_code_involving(*i);
    return false;
}));

Creo que tienes un error allí, lo codifico de esta manera:

for (std::list<CAudioChannel *>::iterator itAudioChannel = audioChannels.begin();
             itAudioChannel != audioChannels.end(); )
{
    CAudioChannel *audioChannel = *itAudioChannel;
    std::list<CAudioChannel *>::iterator itCurrentAudioChannel = itAudioChannel;
    itAudioChannel++;

    if (audioChannel->destroyMe)
    {
        audioChannels.erase(itCurrentAudioChannel);
        delete audioChannel;
        continue;
    }
    audioChannel->Mix(outBuffer, numSamples);
}