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) ?

Answer 1

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.

Answer 2

             #include<iostream>
             #include<string.h>
             #include<vector>
             #include<algorithm>
             using namespace std;


             class Customer;
             class flipkart
             {
                vector<Customer*>list;
                vector<Customer*>::iterator it;
                public:
                void Register(Customer *customer)
                {
                   list.push_back(customer);
                }
                void unregister(Customer *customer)
                {
                    list.erase(remove(list.begin(), list.end(),customer), list.end()); 
                }

                void notify(string item,float vprice);
             };


             class observer
             {
                 public:
                 virtual void update(string item,float vprice)=0;
             };
             class Customer:public observer
             {
                 string name;
                 public:
                 Customer(string n)
                 {
                     name=n;
                 }

                 void update(string item,float vprice)
                 {
                     cout<<"**Flipkart**updated price for "<<item<<" is:"<<vprice<<" Rupees only, request recieved by "<<name<<endl;
                 }
             };

             void flipkart::notify(string item,float vprice)
             {
                 for(it=list.begin();it!=list.end();it++)
                 {
                     (*it)->update(item,vprice);
                 }
             }

             class product:public flipkart
             {
                 public:
                 void change_price(string item,float vprice)
                 {
                     notify(item,vprice);
                 }
             };

             int main()
             {
                 Customer customer1("Dhoni"),customer2("Yuvraj"),customer3("Kohli");
                 product LCD;

                 LCD.Register(&customer1);
                 LCD.Register(&customer2);
                 LCD.Register(&customer3);

                 LCD.change_price("LCD HD2 TV",12000);

                 LCD.unregister(&customer2);
                 cout<<"after unregisterng customer2:\n";

                 LCD.change_price("LCD HD2 TV",11500);
             }

Answer 3

The Observer design pattern is not defined in the STL. You can refer to the "Gang of four" Design Patterns book or a Google search should provide enough details to implement it. If this question isn't answered soon, I'll post a quick example.

Answer 4

No, but Boost.Signals2 gives you something similar.

Answer 5

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.

Answer 6

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;
}