观察者模式:定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象,当这个主题对象状态发生变化时候,会通知所有观察者对象,使得他们能够自动更新自己。
使用场景:当一个对象的改变需要同时改变其他对象的时候,而且它不知道具体有多少对象有待改变。耦合的双方依赖于抽象不是具体。
现实中的例子:
微博订阅,当订阅的主题有新消息发布时候,订阅者都会收到相应的通知;类似还有天气预报等
结构图:
C++代码:
//观察者模式
#include <iostream>
#include <list>
using namespace std;
class Observer;
//抽象主题或者抽象通知者类
class Subject {
public:
//增加一个观察者
virtual void attach(Observer *pObserver) = 0;
//移除一个观察者
virtual void detach(Observer *pObserver) = 0;
//通知
virtual void notify() = 0;
};
//抽象观察者:为所有的具体观察者定义一个更新自己的接口
class Observer {
public:
virtual void update() = 0;
};
//具体主题类或者具体通知者
class ConcreteSubject : public Subject {
public:
void attach(Observer *pObserver)
{
listObserver.push_back(pObserver);
}
void detach(Observer *pObserver)
{
listObserver.remove(pObserver);
}
void notify()
{
list<Observer*>::iterator iter;
for(iter=listObserver.begin(); iter!=listObserver.end(); ++iter)
{
(*iter)->update();
}
}
const string& getState() const {
return state;
}
void setState(const string& state) {
this->state = state;
}
private:
string state;
list<Observer*> listObserver;
};
//具体观察者
class ConcreteObserver : public Observer {
public:
ConcreteObserver(ConcreteSubject *cs, string n)
: pSubject(cs), name(n)
{}
void update()
{
if(pSubject != NULL)
{
observerState = pSubject->getState();
cout << name << "收到新通知 : " << observerState << endl;;
}
}
private:
ConcreteSubject *pSubject;
string observerState;
string name;
};
int main()
{
ConcreteSubject *pCS = new ConcreteSubject();
ConcreteObserver *pCO_one = new ConcreteObserver(pCS, "观察者1号");
ConcreteObserver *pCO_two = new ConcreteObserver(pCS, "观察者2号");
pCS->attach(pCO_one);
pCS->attach(pCO_two);
pCS->setState("主人要打dota啦...");
pCS->notify();
pCS->detach(pCO_two);
pCS->notify();
delete pCS;
delete pCO_one;
delete pCO_two;
return 0;
}
/*
观察者观察者1号的新通知 : 主人要打dota啦...
观察者观察者2号的新通知 : 主人要打dota啦...
观察者观察者1号的新通知 : 主人要打dota啦...
*/