观察者模式(observer pattern)

观察者模式：

    定义了subject和observer之间的一对多依赖，当subject状态改变时，所有的observer都会收到通知。

结构图：

C++实现：

class Observer;

class Subject {
public:
    virtual void attach(Observer *o) = 0;
    virtual void detach(Observer *o) = 0;
    virtual void notify() = 0;
};

class Observer {
public:
    virtual void update(int val) = 0;
};

class mySubject : public Subject {
private:
    set<Observer*> obs;
    int value;
public:
    void attach(Observer *o) { obs.insert(o); }
    void detach(Observer *o) { obs.erase(o); }
    void setVaule(int val) {
        value = val;
        notify();
    }
    void notify()
    {
        set<Observer*>::iterator it;
        for (it = obs.begin(); it != obs.end(); ++it)
        {
            (*it)->update(value);
        }
    }
    int getValue() { return value; }
};


class observerA : public Observer {
private:
    int value;
    Subject *psj;
public:
    observerA(Subject *p): psj(p) { psj->attach(this); }
    void update(int val)
    {
        value = val;
        display();
    }
    void display()
    {
        printf("current value: %d\n", value);
    }
    ~observerA() { delete psj; }
};

class observerB : public Observer {
private:
    Subject *psj;
public:
    observerB(Subject *p): psj(p) { psj->attach(this); }
    void update(int val)
    {
        if (val > 0)
            printf("good news\n");
        else
            printf("bad news\n");
    }
    ~observerB() { delete psj; }
};

int main()
{
    mySubject subj;
    observerA a(&subj);
    observerB b(&subj);
    subj.setVaule(1);
    subj.detach(&a);
    subj.setVaule(2);
}

 

观察者模式涉及到的一个设计原则是：松耦合设计。改变subject或observer其中一方，并不会影响另一方。只要它们之间的接口仍被遵守，我们就可以自由地改变它们。

PS:

   观察者模式的一个例子是MVC，现在没接触到，先这样吧。。。