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)=;
 };
 class Subject
 {
 private:
     int result;
 public:
     list<Obverser*> obverselist;
     virtual void registerObserver(Obverser* ob)=;
     virtual void removeObserver(Obverser* ob)=;
     virtual void notifyObservers()=;
     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();
     cs->setResult();
     Obverser *cob3 = new concreteObverser3(cs);
     cs->setResult();
     cs->removeObserver(cob2);
     cs->setResult();
     cs->removeObserver(cob1);
     cs->setResult();
     return ;
 }