观察者模式
GOOD:定义了一种一对多的关系,让多个(被)观察对象(公司员工)同时监听一个主题对象(秘书,通知者),主题对象(通知者)状态发生变化时,会通知所有的观察者,使它们能够更新自己。
扩展:观察者模式可细分为两张模式,一种是推送观察者模式,一种是拉取观察者模式。
一对多中,一的对象改变,在通知多的接口中一可以把自己的状态推送给多,即为推送观察者模式,这种模式耦合性比较低,因为一可以对多完全屏蔽自己的任何信息。
另一种就是在通知多的接口中不推送任何消息,只通知多自己的状态改变了,让每个多主动从一中拉取自己需要的数据,即为拉取观察者模式,这种模式在每个多中都需要能够访问到一的地址,但可避免推送观察者模式中推送状态重构时,每个多都需要修改的弊端。
转载请注明,文章来自:http://blog.csdn.net/windows_nt
示例:
#include <string>
#include <iostream>
#include <vector>
using namespace std;
class Secretary;
//看股票的同事类(观察对象,观察者)
class StockObserver
{
private:
string name;
Secretary* sub;
public:
StockObserver(string strname,Secretary* strsub)
{
name=strname;
sub=strsub;
}
void Update();
};
//秘书类(主题对象,通知者)
class Secretary
{
private:
vector<StockObserver> observers;
public:
string action;
void Add(StockObserver ob)
{
observers.push_back(ob);
}
void Notify()
{
vector<StockObserver>::iterator p = observers.begin();
while (p!=observers.end())
{
(*p).Update();
p++;
}
}
};
void StockObserver::Update()
{
cout<<name<<":"<<sub->action<<",不要玩股票了,要开始工作了"<<endl;
}
//客户端
int main()
{
Secretary *p=new Secretary(); //创建通知者
//观察者
StockObserver *s1= new StockObserver("小李",p);
StockObserver *s2 = new StockObserver("小赵",p);
//加入通知队列
p->Add(*s1);
p->Add(*s2);
//事件
p->action="老板来了";
//通知
p->Notify();
return 0;
}
#include <string>
#include <iostream>
#include <vector>
using namespace std;
class SecretaryBase;
//抽象观察者
class CObserverBase
{
protected:
string name;
SecretaryBase* sub;
public:
CObserverBase(string strname,SecretaryBase* strsub)
{
name=strname;
sub=strsub;
}
virtual void Update()=0;
};
//具体的观察者,看股票的
class StockObserver : public CObserverBase
{
public:
StockObserver(string strname,SecretaryBase* strsub) : CObserverBase(strname,strsub)
{
}
virtual void Update();
};
//具体观察者,看NBA的
class NBAObserver : public CObserverBase
{
public:
NBAObserver(string strname,SecretaryBase* strsub) : CObserverBase(strname,strsub){}
virtual void Update();
};
//抽象通知者
class SecretaryBase
{
public:
string action;
vector<CObserverBase*> observers;
public:
virtual void Attach(CObserverBase* observer)=0;
virtual void Notify()=0;
};
//具体通知者
class Secretary :public SecretaryBase
{
public:
void Attach(CObserverBase* ob)
{
observers.push_back(ob);
}
void Notify()
{
vector<CObserverBase*>::iterator p = observers.begin();
while (p!=observers.end())
{
(*p)->Update();
p++;
}
}
};
void StockObserver::Update()
{
cout<<name<<":"<<sub->action<<",不要玩股票了,要开始工作了"<<endl;
}
void NBAObserver::Update()
{
cout<<name<<":"<<sub->action<<",不要看NBA了,老板来了"<<endl;
}
//客户端:
int main()
{
SecretaryBase *p=new Secretary(); //创建观察者
//被观察的对象
CObserverBase *s1= new NBAObserver("小李",p);
CObserverBase *s2 = new StockObserver("小赵",p);
//加入观察队列
p->Attach(s1);
p->Attach(s2);
//事件
p->action="老板来了";
//通知
p->Notify();
return 0;
}
智能化观察者模式,不用客户端手动把被观察者加入观察队列,但破坏了封装性,在多线程编程中会有很大的问题。
#include <string>
#include <iostream>
#include <vector>
using namespace std;
class CObserverBase; //抽象观察者
//具体通知者
class Secretary
{
public:
static vector<CObserverBase*> m_ObServerBase;
public:
Secretary() {}
virtual ~Secretary() {}
static void Attach(CObserverBase* ob)
{
m_ObServerBase.push_back(ob);
}
static void Notify();
};
//抽象观察者
class CObserverBase
{
public:
CObserverBase* m_pObserverBase;
public:
CObserverBase() { m_pObserverBase = NULL; Connect(); }
virtual CObserverBase::~CObserverBase() { Disconnect(); }
void Connect()
{
if (m_pObserverBase) return;
Secretary::Attach(this);
m_pObserverBase = this;
}
void Disconnect() {}
virtual void OnUpdate() {}
};
void Secretary::Notify()
{
vector<CObserverBase*>::iterator p = m_ObServerBase.begin();
while (p != m_ObServerBase.end())
{
(*p)->OnUpdate();
p++;
}
}
//具体的观察者,看股票的
class StockObserver : public CObserverBase
{
public:
StockObserver(string strname,Secretary* strsub)
{
}
virtual void OnUpdate();
};
//具体观察者,看NBA的
class NBAObserver : public CObserverBase
{
public:
NBAObserver(string strname,Secretary* strsub)
{
}
virtual void OnUpdate();
};
void StockObserver::OnUpdate()
{
cout<<"CBA:"<<"不要玩股票了,要开始工作了"<<endl;
}
void NBAObserver::OnUpdate()
{
cout<<"NBA:"<<"不要看NBA了,老板来了"<<endl;
}
vector<CObserverBase*> Secretary::m_ObServerBase;
//客户端:
int main()
{
//创建观察者
Secretary* p = new Secretary;
//被观察的对象
NBAObserver *s1= new NBAObserver("小李",p);
StockObserver *s2 = new StockObserver("小赵",p);
//通知
p->Notify();
return 0;
}