观察者模式
观察者模式定义对象间的一种一对多的依赖关系,当一个对象的状态发生变化时,所有依赖于它的对象都得到通知并被自动更新,先看一个简单的观察者模式是如何实现的
class Subject;
class Observer
{
public:
virtual ~Observer();
virtual void Update(Subject* theChangedSubject)=0;
protected:
Observer();
};
class Subject
{
public:
virtual ~Subject();
virtual void Attach(Observer*);
virtual void Detach(Observer*);
virtual void Notify();
protected:
Subject();
private:
List<Observer*> *_observers;
};
void Subject::Attach(Observer* o)
{
_observers->Append(o);
}
void Subject::Detach(Observer* o)
{
_observers->Remove(o);
}
void Subject::Notify()
{
ListIterator<Observer*> i(_observers);
for(i.First();!i.IsDone();i.Next())
{
i.CurrentItem()->Update(this);
}
}
这种实现方式限制太多,最主要的两个限定是:第一,需要继承,继承是强对象关系,不够灵活,第二,观察者模式被通知的接口参数不支持变化,导致观察者不能应付接口的变化。
C++11改进观察者模式实现
class NonCopyable
{
protected:
NonCopyable()=default;
~NonCopyable()=default;
NonCopyable(const NonCopyable&)=delete;
NonCopyable& operator = (const NonCopyable&)=delete;
};
#include<iostream>
#include<string>
#include<functional>
#include<map>
using namespace std;
template<typename Func>
class Events:NonCopyable
{
public:
Events()
{}
~Events(){}
int Connect(Func&& f)
{
return Assgin(f);
}
int Connect(const Func& f)
{
return Assgin(f);
}
void Disconnect(int key)
{
m_connections.erase(key);
}
template<typename... Args>
void Notify(Args&&... args)
{
for(auto& it:m_connections)
{
it.second(std::forward<Args>(args)...);
}
}
private:
template<typename F>
int Assgin(F&& f)
{
int k=m_observerId++;
m_connections.emplace(k,std::forward<F>(f));
return k;
}
int m_observerId=0;
std::map<int,Func> m_connections;
};
struct stA
{
int a,b;
void print(int a,int b)
{
cout<<a<<", "<<b<<endl;
}
};
void print(int a,int b)
{
cout<<a<<", "<<b<<endl;
}
int main()
{
Events<std::function<void(int,int)>> myevent;
auto key=myevent.Connect(print);
stA t;
auto lambdakey=myevent.Connect([&t](int a,int b){t.a=a;t.b=b;});
std::function<void(int,int)> f=std::bind(&stA::print,&t,std::placeholders::_1,std::placeholders::_2);
myevent.Connect(f);
int a=1,b=2;
myevent.Notify(a,b);
myevent.Disconnect(key);
}
c++11实现的观察者模式,内部维护了一个泛型函数列表,观察者只需要将观察者函数注册进去即可,通知接口使用了可变参数模板,支持任意参数,消除了接口变化的影响