contenitore osservabile per C++

Question

Esiste un'implementazione di classi contenitore per C++ che supporta la notifica in modo simile a ObservableCollection per C#?

Answer 1

Non esiste una classe standard come la descrizione, ma Boost.Signals è piuttosto una potente libreria di notifica. Vorrei creare un wrapper per gli oggetti che solleva un segnale quando viene cambiato, lungo le linee di questo:

#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

Non c'è niente di simile in STL. Ciò non significa che qualcuno non abbia creato una cosa simile in una libreria open source, ma non credo che faccia parte della lingua.

Answer 3

Sarà necessario scrivere il proprio e appoggiarlo sul contenitore preferito.

Answer 4

Il modo in cui lo sto facendo ho qualcosa di simile notify_updated e wait_event nella mia collezione, e mi chiamare notify_updated dopo aver apportato le modifiche, quindi in altre parti sono in attesa di eventi. La mia soluzione è molto specifica per il problema che sto risolvendo, quindi è più C-ish. Ho pensato che fosse simile concettualmente al campione di Mike.