head first 设计模式 观察者模式

Head first 设计模式:定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会受到通知并自动更新。   让主题与观察者之间松耦合

大话设计模式:定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

设计模式:描述了如何建立这种关系。这一模式中的关键对象是  目标(subject)和观察者(observer)。一个目标可以有任意数目的依赖他的观察者。一旦目标的状态发生改变，所有的观察者都会收到通知。作为对这个通知的相应，每个观察者都将查询目标以使其状态与目标的状态同步。也成为  发布 - 订阅 。

设计原则:为了交互对象之间的松耦合设计而努力

松耦合的设计之所以能让我们建立有弹性的OO系统，能够应对变化，是因为对象之间的相互依赖降到了最低。

#include "stdafx.h"
#include<iostream>
#include<list>
using namespace std;
/*观察者模式*/
class Subject;
class Obverser
{
public:
    Subject* sub;
    Obverser(Subject* sb):sub(sb){}
    virtual void update(Subject* sb)=0;
};
class Subject
{    
private:
    int result;
public:
    list<Obverser*> obverselist;
    virtual void registerObserver(Obverser* ob)=0;
    virtual void removeObserver(Obverser* ob)=0;
    virtual void notifyObservers()=0;
    virtual void setResult(int i)
    {
        result =i;
        notifyObservers();
    }
    virtual int retResult(){return result;}
};

class ConcreteSubject:public Subject
{
public:
    virtual void registerObserver(Obverser* ob)
    {
        obverselist.push_back(ob);
    }
    virtual void removeObserver(Obverser* ob)
    {
        list<Obverser*>::iterator it= obverselist.begin();
        while(it!=obverselist.end())
        {
            if(*it == ob)
            {
                it=obverselist.erase(it);
            }else{
                it++;
            }
        }
    }
    virtual void notifyObservers()
    {
        for(list<Obverser*>::iterator it=obverselist.begin();it!=obverselist.end();++it)
        {
            (*it)->update(this);
        }
    }
};

class concreteObverser1:public Obverser
{
public:
    concreteObverser1(Subject* sb):Obverser(sb)
    {
        sub->registerObserver(this);
    }
    virtual void update(Subject *sb)
    {
        cout<<"我是观察者1号,我收到通知了"<<sb->retResult()<<endl;;
    }
};

class concreteObverser2:public Obverser
{
public:
    concreteObverser2(Subject* sb):Obverser(sb)
    {
        sub->registerObserver(this);
    }
    virtual void update(Subject *sb)
    {
        cout<<"我是观察者2号,我收到通知了"<<sb->retResult()<<endl;
    }
};

class concreteObverser3:public Obverser
{
public:
    concreteObverser3(Subject* sb):Obverser(sb)
    {
        sub->registerObserver(this);
    }
    virtual void update(Subject *sb)
    {
        cout<<"我是观察者3号,我收到通知了"<<sb->retResult()<<endl;
    }
};
int _tmain(int argc, _TCHAR* argv[])
{
    Subject *cs=new ConcreteSubject;
    Obverser *cob1 = new concreteObverser1(cs);
    Obverser *cob2 = new concreteObverser2(cs);
    cs->setResult(1);
    cs->setResult(10);
    Obverser *cob3 = new concreteObverser3(cs);
    cs->setResult(6);
    cs->removeObserver(cob2);
    cs->setResult(7);
    cs->removeObserver(cob1);
    cs->setResult(8);
    return 0;
}