观察者模式
观察者模式它定义了一种依赖-many，听某一个主题对象。这个主题对象在状态发生变化时，会通知全部观察者对象。使他们可以自己主动更新自己。
Subject类，它把全部对观察者对象的引用保存在一个聚集里，每一个主题都能够有随意数量的观察者。
抽象提供一个接口。能够添加和删除观察者对象。
ConcreteSubject类，详细通知者。将有关状态存入详细观察者对象；在详细主题的内部状态发生改变时，给全部登记过的观察者发出通知。
Observer类，抽象观察者。为全部详细观察者定义一个接口，在得到主题的通知时更新自己。
ConcreteObserver类，详细观察者，实现抽象观察者角色所要求的更新接口，以便使本身状态与主题的状态相协调。
应用观察者模式的动机和场景
动机：将一个系统切割成一系类相互协作的类有一个非常不好的副作用，那就是须要维护相关对象的一致性。为了维护一致性使相关类紧密的耦合在一起给维护、扩展和重用都带来了不便。观察者模式所做的就是解耦。
场景：
- 当一个对象的改变须要同一时候改变其它对象的时候。并且不知道详细有多少对象有待改变时。应该考虑使用观察者模式。
- 当一个抽象模型有两个方面。当中一方面依赖于还有一方面。这时用观察者模式能够将这两者封装在独立的对象中使他们各自独立的改变和复用。
从而使得各自的变化都不会影响还有一边的变化。
代码：
//Observer.h
#include "stdafx.h"
#include <iostream>
#include <vector>
#include <string>
using namespace std;
class Observer
{
public:
virtual void Update() = 0;
virtual ~Observer(){}
};
class Subject
{
public:
virtual ~Subject(){}
virtual void Attach(Observer* observer)
{
_observers.push_back(observer);
}
virtual void Detach(Observer* observer)
{
vector<Observer*>::iterator it = find(_observers.begin(), _observers.end(), observer);
_observers.erase(it);
}
virtual void Notify()
{
for each (Observer* o in _observers)
{
o->Update();
}
}
private:
vector<Observer*> _observers = vector<Observer*>();
};
class ConcreteSubject :public Subject
{
public :
~ConcreteSubject(){}
string SubjectState;
};
class ConcreteObserver :public Observer
{
private:
string _name;
string _ObserverState;
ConcreteSubject *_pSubject;
public:
ConcreteObserver( ConcreteSubject *subject, string name)
{
_pSubject = subject;
_name = name;
}
virtual void Update()
{
_ObserverState = _pSubject->SubjectState;
cout << "观察者："<<_name<<" 当前状态："<<_ObserverState << endl;
}
};
// ObserverPattern.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include "Observer.h"
int _tmain(int argc, _TCHAR* argv[])
{
ConcreteSubject *s = new ConcreteSubject();
s->Attach(new ConcreteObserver(s, "x"));
s->Attach(new ConcreteObserver(s, "y"));
s->SubjectState = "老板回来了";
s->Notify();
getchar();
return 0;
}
版权声明：本文博客原创文章，博客，未经同意，不得转载。
