¿Se pueden eliminar elementos de una lista std::mientras se itera a través de ella?

Quieres hacer:

i= items.erase(i);

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

Necesitas hacer la combinación de la respuesta de Kristo y la de 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 != items.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 SuperCool ® STL savy 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: Trabajar con colecciones debe ser como: 1. prepara la colección. 2. proceso de recogida.

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

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

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

Se pierde algo de eficiencia, se retrocede y luego se avanza de nuevo al eliminar, pero a cambio del incremento del iterador adicional, se puede declarar el iterador en el ámbito del bucle y el código se ve un poco más limpio. Qué elegir depende de las prioridades del momento.

La respuesta estaba 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);
    }
}

Aquí hay un ejemplo usando un bucle for que itera la lista e incrementa o revalida el iterador en el caso de que un elemento se elimine 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 eliminación invalida solo los iteradores que apuntan a los elementos que se eliminan.

Así que en este caso después de eliminar *i , i se invalida y no se puede hacer 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.

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_if el modismo debe usarse cuando items es un vector en lugar de una lista para mantener la compexidad en O (n), o en caso de que escriba código genérico y items puedan 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;
}));

Si piensa en el std::list como una cola, entonces puede desqueuear y enqueue todos los elementos que desea mantener, pero solo desqueue (y no enqueue) 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á números 1-4 y 6-10.

Creo que tienes un error ahí, 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);
}