观察者模式
定义：
定义一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。
实用性：
1、当一个抽象模型有两个方面，其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自地改变和复用。
2、当一个对象改变时需要同时改变其它对象，而不知道具体有多少对象有待改变。
3、当一个对象必须通知其他对象，而它又不能假定其它对象是谁。也就是说，不希望这些对象是紧密耦合的。
优点：
1、 目标和观察这间抽象耦合。
2、 支持广播通信
缺点：
可能出现意外更新。
实现：
class Subject;
class Observer
{
public:
virtual~Observer() {}
virtual void Handle(Subject *pSubject) = 0;
};
class Subject
{
public:
virtual~Subject()
{
}
voidAttack(Observer *pObserver)
{
m_ObserverList.push_back(pObserver);
}
voidDetach(Observer *pObserver)
{
m_ObserverList.remove(pObserver);
}
voidNotify()
{
for (list
{
(*it)->Handle(this);
}
}
virtualstring GetName()
{
return "";
}
virtual void SetState(string state)
{
}
virtual stringGetState()
{
return "";
}
private:
list
};
class ConcreteSubject:public Subject
{
public:
ConcreteSubject(string name):m_name(name)
{
}
string GetState()
{
return m_state;
}
void SetState(string state)
{
m_state = state;
}
string GetName()
{
return m_name;
}
private:
string m_state;
string m_name;
};
class ConcreteObserver:public Observer
{
public:
ConcreteObserver(stringname):m_name(name)
{
}
voidHandle(Subject *pSubject)
{
cout<
cout<
}
private:
string m_name;
};
Observer *pObserver1 = new ConcreteObserver("观察者1");
Observer *pObserver2 = new ConcreteObserver("观察者2");
Observer *pObserver3 = new ConcreteObserver("观察者3");
Subject *pSubject1 = new ConcreteSubject("目标对象1");
Subject *pSubject2 = new ConcreteSubject("目标对象2");
pSubject1->Attack(pObserver1);
pSubject1->Attack(pObserver2);
pSubject1->Attack(pObserver3);
pSubject2->Attack(pObserver2);
pSubject2->Attack(pObserver3);
pSubject1->SetState("工作中。。。");
pSubject2->SetState("休息中。。。");
pSubject1->Notify();
pSubject2->Notify();
pSubject2->SetState("工作中。。。");
pSubject1->SetState("休息中。。。");
pSubject1->Notify();
pSubject2->Notify();