设计模式之观察者模式

1,解决的问题:
当某些其他对象改变状态时,如果一组对象需要进行相应的更新,那么应该如何处理.
2,实例代码:

#include <vector>
#include <set>
#include <iostream>
using namespace std;

class Observable;
class Argument {};

class Observer
{
public:
    virtual void update(Observable* o, Argument* arg) = 0;
    virtual ~Observer() {}
};

class Observable
{
    bool changed;
    std::set<Observer*> observers;
protected:
    virtual void setChanged() { changed = true; }
    virtual void clearChanged() { changed = false; }
public:
    //被观察者的行为
    virtual void addObserver(Observer& o) { observers.insert(&o); }
    virtual void deleteObserver(Observer& o) { observers.erase(&o); }
    virtual void deleteObservers() { observers.clear(); }
    virtual int countObservers() { return observers.size(); }
    virtual bool hasChanged() { return changed; }
    //通知观察者作出反应
    virtual void notifyObservers(Argument* arg = 0)
    {
        if(!hasChanged()) return;
        clearChanged(); // Not "changed" anymore
        std::set<Observer*>::iterator it;
        for(it = observers.begin();it != observers.end(); it++)
            (*it)->update(this, arg);
    }
    virtual ~Observable() {}
};

class Flower //被观察者
{
    bool isOpen;
public:
    Flower() : isOpen(false),openNotifier(this), closeNotifier(this) {}
    void open()
    {
        isOpen = true;
        openNotifier.notifyObservers();
        closeNotifier.open();
    }
    void close()
    {
        isOpen = false;
        closeNotifier.notifyObservers();
        openNotifier.close();
    }
    // 使用内部类,先声明,再友元,然后定义
    class OpenNotifier;
    friend class Flower::OpenNotifier;
    class OpenNotifier : public Observable
    {
        Flower* parent;
        bool alreadyOpen;
    public:
        OpenNotifier(Flower* f) : parent(f), alreadyOpen(false) {}
        void notifyObservers(Argument* arg = 0)
        {
            if(parent->isOpen && !alreadyOpen)
            {
                setChanged();
                Observable::notifyObservers();
                alreadyOpen = true;
            }
        }
        void close() { alreadyOpen = false; }
    } openNotifier;

    class CloseNotifier;
    friend class Flower::CloseNotifier;
    class CloseNotifier : public Observable
    {
        Flower* parent;
        bool alreadyClosed;
        public:
        CloseNotifier(Flower* f) : parent(f), alreadyClosed(false) {}
        void notifyObservers(Argument* arg = 0)
        {
            if(!parent->isOpen && !alreadyClosed)
            {
                setChanged();
                Observable::notifyObservers();
                alreadyClosed = true;
            }
        }
        void open() { alreadyClosed = false; }
    } closeNotifier;
};

class Bee
{
    string name;
    //内部类作为两个私有成员
    class OpenObserver;
    friend class Bee::OpenObserver;
    class OpenObserver : public Observer
    {
        Bee* parent;
    public:
        OpenObserver(Bee* b) : parent(b) {}
        void update(Observable*, Argument *)
        {
            cout << "Bee " << parent->name << "'s breakfast time!" << endl;
        }
    } openObsrv;
  // Another "inner class" for closings:
    class CloseObserver;
    friend class Bee::CloseObserver;
    class CloseObserver : public Observer
    {
        Bee* parent;
    public:
        CloseObserver(Bee* b) : parent(b) {}
        void update(Observable*, Argument *)
        {
            cout << "Bee " << parent->name << "'s bed time!" << endl;
        }
    } closeObsrv;
public:
    Bee(string nm) : name(nm),openObsrv(this), closeObsrv(this) {}
    Observer& openObserver() { return openObsrv; }
    Observer& closeObserver() { return closeObsrv;}
};

class Hummingbird
{
    string name;
    class OpenObserver;
    friend class Hummingbird::OpenObserver;
    class OpenObserver : public Observer
    {
        Hummingbird* parent;
    public:
        OpenObserver(Hummingbird* h) : parent(h) {}
        void update(Observable*, Argument *)
        {
            cout << "Hummingbird " << parent->name << "'s breakfast time!" << endl;
        }
    } openObsrv;
    class CloseObserver;
    friend class Hummingbird::CloseObserver;
    class CloseObserver : public Observer
    {
        Hummingbird* parent;
    public:
        CloseObserver(Hummingbird* h) : parent(h) {}
        void update(Observable*, Argument *)
        {
            cout << "Hummingbird " << parent->name << "'s bed time!" << endl;
        }
    } closeObsrv;
public:
    Hummingbird(string nm) : name(nm), openObsrv(this), closeObsrv(this) {}
    Observer& openObserver() { return openObsrv; }
    Observer& closeObserver() { return closeObsrv;}
};

int main()
{
    Flower f;
    Bee ba("A"), bb("B");
    Hummingbird ha("A"), hb("B");
    f.openNotifier.addObserver(ha.openObserver());
    f.openNotifier.addObserver(hb.openObserver());
    f.openNotifier.addObserver(ba.openObserver());
    f.openNotifier.addObserver(bb.openObserver());
    f.closeNotifier.addObserver(ha.closeObserver());
    f.closeNotifier.addObserver(hb.closeObserver());
    f.closeNotifier.addObserver(ba.closeObserver());
    f.closeNotifier.addObserver(bb.closeObserver());
    // Hummingbird B decides to sleep in:
    f.openNotifier.deleteObserver(hb.openObserver());
    // Something changes that interests observers:
    f.open();
    f.open(); // It's already open, no change.
    // Bee A doesn't want to go to bed:
    f.closeNotifier.deleteObserver(ba.closeObserver());
    f.close();
    f.close(); // It's already closed; no change
    f.openNotifier.deleteObservers();
    f.open();
    f.close();
}