Delete element from a iterating list from an event - c++

Question

Wanted to know what is the best way to delete an element from a list which is being iterating continuously in an event loop.
I have an event loop where my list is getting updated
for (auto pIt = this->particles.begin(); pIt != this->particles.end(); pIt++) {
(*pIt)->Update(system, gameTime);
}
At a certain event based time I have to remove a random element from the list.
It is handled in a separate function using:
this->particles.remove_if([particle](Particle *ptc)->bool {
return ptc == particle;
});
This gives a list iteration runtime error because the iterators in the loop become invalid. What is the optimal way to solve such kind of situation?

Answer 1

I am assuming the deleting of the element happens inside the Update() function and the "list" is actually std::list and not a std::vector.
Do not perform pIt++ in the loop header. Instead, do pIt++ BEFORE calling Update(). Call Update() on the original object that is returned:
for (auto pIt = this->particles.begin(); pIt != this->particles.end(); ) {
auto pForCall = *(pIt++);
pForCall->Update(system, gameTime);
}
Another case where this will not work is when the element being delete is not the element we're calling Update on.

Answer 2

The erasing function must have access to the iterator used in the loop (make it a member variable) and if that iterator points to the element being deleted increment the iterator. This way you keep the loop iterator from being invalidated by erasing.
Example:
#include <iostream>
#include <list>
struct Explosion;
struct Particle {
void update(Explosion&);
};
struct Explosion {
std::list<Particle> particles;
std::list<Particle>::iterator particle_iter;
void update() {
for(particle_iter = particles.begin(); particle_iter != particles.end(); ) {
auto to_call = particle_iter++;
to_call->update(*this);
}
}
template<class Condition>
void filter(Condition condition) {
for(auto i = particles.begin(); i != particles.end();) {
auto to_remove = i++;
if(condition(*to_remove)) {
// Remove the element.
if(particle_iter == to_remove)
particle_iter = i;
particles.erase(to_remove);
}
}
}
};
void Particle::update(Explosion& explosion) {
explosion.filter([this](Particle& other) { return this == &other; });
// The above ends up destroying this object.
// Cannot no longer access this and should only return.
}
int main() {
Explosion explosion{{Particle{}, Particle{}}, {}};
std::cout << explosion.particles.size() << '\n';
explosion.update();
std::cout << explosion.particles.size() << '\n';
}