Observer design pattern in C++

Question

Is the observer design pattern already defined in STL (Like the java.util.Observer and java.util.Observable in Java) ?

Solution 1

Here is a reference implementation (from Wikipedia).

#include <iostream>
#include <string>
#include <map>
#include <boost/foreach.hpp>

class SupervisedString;
class IObserver{
public:
    virtual void handleEvent(const SupervisedString&) = 0;
};


class SupervisedString{ // Observable class
    std::string _str;
    std::map<IObserver* const, IObserver* const> _observers;

    typedef std::map<IObserver* const, IObserver* const>::value_type item;

    void _Notify(){
        BOOST_FOREACH(item iter, _observers){
            iter.second->handleEvent(*this);
        }
    }

public:
    void add(IObserver& ref){
        _observers.insert(item(&ref, &ref));
    }

    void remove(IObserver& ref){
        _observers.erase(&ref);
    }

    const std::string& get() const{
        return _str;
    }

    void reset(std::string str){
        _str = str;
        _Notify();
    }
};


class Reflector: public IObserver{ // Prints the observed string into std::cout
public:
    virtual void handleEvent(const SupervisedString& ref){
        std::cout<<ref.get()<<std::endl;
    }
};

class Counter: public IObserver{  // Prints the length of observed string into std::cout
    virtual void handleEvent(const SupervisedString& ref){
        std::cout<<"length = "<<ref.get().length()<<std::endl;
    }
};

int main(){

    SupervisedString str;
    Reflector refl;
    Counter    cnt;

    str.add(refl);
    str.reset("Hello, World!");
    std::cout<<std::endl;

    str.remove(refl);
    str.add   (cnt);
    str.reset("World, Hello!");
    std::cout<<std::endl;

    return 0;
}

Solution 2

No, but Boost.Signals2 gives you something similar.

Solution 3

As far as my knowledge goes in C++, STL doesn't have an implementation for Observer pattern. There was a proposal for Signal/Slot for standard library in TR2 though.

There are plenty of libraries which provides implementation for Observer pattern Qt library being one of the pioneers. The boost library has an implementation (see Boost::Signals & Boost::Signals2).

The Poco C++ library has a neat implementation of the observer pattern (see NotificationCenter).

libsigc++, cpp-events are some of the other libraries that provide signal/slot implementations.

Solution 4

No it doesn't. The C++ STL is much smaller than Java's Standard Library. If you are looking for something to expand on the STL that is supported by almost everything, it would be worth taking a look at the Boost libraries. In this case you may want to look at Boost.Signals which provides a signal/slot model.

Solution 5

#include <iostream>
#include <string>
#include <set>
using namespace std;
class Subject;
class Observer {
public:
  virtual void update(Subject & subject) = 0;
};
// also knows as Observable in literature
class Subject
{
  string state;
  set<Observer*> observers;
public:
  void attachObserver(Observer *o) { observers.insert(o); }
  void detachObserver(Observer *o) { observers.erase(o); }
  void notifyObservers()
  {
    for (auto &o : observers)
    {
      o->update(*this);
    }
  }
  string getState() { return state; }
  void changeState(const string & s)
  {
    state = s;
    notifyObservers();
  }
};
class ObserverImpl : public Observer
{
  string state;
public:
  void update(Subject & sbj) override
  {
    state = sbj.getState();
  }
  string getState() { return state; }
};
int main()
{
  ObserverImpl a, b, c;
  Subject subject;
  subject.attachObserver(&a);
  subject.attachObserver(&b);
  subject.attachObserver(&c);
  subject.changeState("Observer pattern");
  cout << a.getState() << endl;
  cout << b.getState() << endl;
  cout << c.getState() << endl;
  return 0;
}

please also see UML/flow diagrams http://codepatterns.ddns.net/

View more solutions