C++设计模式之十九：Observer（观察者模式）

一、意图：

定义对象间的一种一对多的依懒关系，当一个对象发生变化的时候，所有依赖与他的对象都能得到通知。

二、类图：



三、 组成元素：

                   i.           Subject:被观察者接口

                  ii.           ConcreteSubject：具体被观察者

                iii.           Observer：观察者

                iv.           ConcreteObserver：具体的观察者

四、代码实现：

#include "iostream"
#include "list"
#include <string>

using namespace std;

class Subject;
class Observer;

class Subject
{
public:
virtual void attach(Observer* ob)=0;
virtual void detch(Observer* ob)=0;
virtual void notify()=0;
virtual string GetState()=0;
};

class Observer
{
public:
Observer(Subject *sub)
{
m_subject=sub;
}
virtual void Update()=0;
protected:
Subject* m_subject;
};

class ConcreteSubject: public Subject
{
private:
list<Observer*> observers;
string subjectState;
public:
virtual void attach(Observer* ob)
{
observers.push_back(ob);
}
virtual void detch(Observer* ob)
{
observers.remove(ob);
}
virtual void notify()
{
list<Observer*>::iterator it;
for (it=observers.begin();it!=observers.end();it++)
{
(*it)->Update();
}
}
virtual string GetState()
{
return subjectState;
}
virtual void SetState(const string str)
{
this->subjectState=str;
}
};

class ConcreteObserverA:public Observer
{
public:
ConcreteObserverA(Subject *sub):Observer(sub)
{
m_subject=sub;
}
virtual void Update()
{
cout<<"A received "<<m_subject->GetState()<<endl;
}
private:
string observerState;
};
class ConcreteObserverB:public Observer
{
public:
ConcreteObserverB(Subject *sub):Observer(sub)
{
m_subject=sub;
}
virtual void Update()
{
cout<<"B received "<<m_subject->GetState()<<endl;
}
private:
string observerState;
};

void main()
{
ConcreteSubject* cs=new ConcreteSubject();
cs->SetState("ConcreteSubject send command!");

ConcreteObserverA* ca=new ConcreteObserverA(cs);
ConcreteObserverB* cb=new ConcreteObserverB(cs);

cout<<"1"<<endl;
cs->attach(ca);
cs->attach(cb);
cs->notify();

cout<<"2"<<endl;
cs->detch(cb);
cs->notify();

delete cs;
delete ca;
delete cb;

}