contenedor observable para C++

Question

¿Hay una implementación de clases de contenedor para C++ que admita la notificación de forma similar a ObservableCollection para C#?

Answer 1

No existe una clase estándar como la que describes, pero Boost.Signals es una biblioteca de notificaciones bastante potente. Me gustaría crear un contenedor para objetos que plantea una señal cuando se cambia, a lo largo de las líneas de este:

#include <boost/signals.hpp> 
#include <vector> 
#include <iostream> 

// Wrapper to allow notification when an object is modified. 
template <typename Type> 
class Observable 
{ 
public: 
    // Instantiate one of these to allow modification. 
    // The observers will be notified when this is destroyed after the modification. 
    class Transaction 
    { 
    public: 
     explicit Transaction(Observable& parent) : 
      object(parent.object), parent(parent) {} 
     ~Transaction() {parent.changed();} 
     Type& object; 

    private: 
     Transaction(const Transaction&); // prevent copying 
     void operator=(const Transaction&); // prevent assignment 

     Observable& parent; 
    }; 

    // Connect an observer to this object. 
    template <typename Slot> 
    void Connect(const Slot& slot) {changed.connect(slot);} 

    // Read-only access to the object. 
    const Type& Get() const {return object;} 

private: 
    boost::signal<void()> changed; 
    Type object; 
}; 

// Usage example 
void callback() {std::cout << "Changed\n";} 

int main() 
{ 
    typedef std::vector<int> Vector; 

    Observable<Vector> o; 
    o.Connect(callback); 

    { 
     Observable<Vector>::Transaction t(o); 
     t.object.push_back(1); 
     t.object.push_back(2); 
    } // callback called here 
} 

Answer 2

No existe tal cosa en STL. Eso no significa que alguien no haya creado tal cosa en una biblioteca de código abierto, pero no creo que sea parte del lenguaje.

Answer 3

Tendrá que escribir el suyo y volver a colocarlo en su contenedor favorito.

Answer 4

La forma en que lo hago tengo algo así como notify_updated y wait_event en mi colección, y me llame notify_updated después de realizar los cambios, y luego en otras partes estoy esperando los eventos. Mi solución es muy específica para el problema que estoy resolviendo, así que es más C-ish. Pensé que es similar conceptualmente a la muestra de Mike.