Tengo un contenedor (C ++) en el que necesito operar de dos maneras, desde diferentes hilos: 1) Agregar y quitar elementos, y 2) iterar a través de sus miembros. Claramente, elimine el elemento mientras ocurre la iteración = desastre. El código se parece a esto:

class A
{
public:
   ...
   void AddItem(const T& item, int index) { /*Put item into my_stuff at index*/ }
   void RemoveItem(const T& item) { /*Take item out of m_stuff*/ }
   const list<T>& MyStuff() { return my_stuff; } //*Hate* this, but see class C
private:
   Mutex mutex; //Goes in the *Item methods, but is largely worthless in MyStuff()
   list<T> my_stuff; //Just as well a vector or deque
};
extern A a; //defined in the .cpp file

class B
{
   ...
   void SomeFunction() { ... a.RemoveItem(item); }
};

class C
{
   ...
   void IterateOverStuff()
   {
      const list<T>& my_stuff(a.MyStuff());
      for (list<T>::const_iterator it=my_stuff.begin(); it!=my_stuff.end(); ++it)
      {
          ...
      }
   }
};

Otra vez,B::SomeFunction() yC::IterateOverStuff() se llaman asincrónicamente. ¿Qué es una estructura de datos que puedo usar para asegurar que durante la iteración,my_stuff está 'protegido' de las operaciones de agregar o quitar?