C++模拟C#事件委托机制（一）

原文来自于http://www.cnblogs.com/netssfy/articles/1652671.html

写了一段时间的C#代码后确实发现C#的事件委托非常好用。
于是便想是否在C++中也能如此实现。
其实事件委托机制的根本还是回调。由于C#编译器帮我们做了很多事，所以我们在订阅委托时就显的非常的方便。

其实在C++里，实现回调也是非常方便的，函数指针就是为他存在的。
但是，麻烦就麻烦在类成员函数指针的类型上
一个非成员函数void Fun(void)和一个 void Class::Fun(void)的类型是截然不同的。

在C#中，如果定义了一个委托delegate void FunDelegate(void)和事件event FunDelegate event1
那么不管是Class1的成员函数Fun还是Class2上的成员函数Fun都能很方便的订阅到事件上，不需要考虑类的类别
Class1 class1;
Class2 class2;
event1 += class1.Fun;
event1 += class2.Fun;

但是C++则不同，首先Class1中的成员函数Fun的类型为void Class1::Fun(void)
那么这类型的指针就为void Class1::*Fun(void),Class2也同样.
所以他们没有办法定于到一半的函数指针上,即使回返值和参数类型相同,如果这样做,编译器会报类型转换错误.

分析:
对于一个事件委托机制来说,一个事件可以被多个观察者侦听,且不关心这些观察者的类型是什么,即无论是Class1的Fun还是Class2的Fun
都可以侦听同一个类型的事件

设计:
首先,肯定会想到用模板,但是如果CEvent<ObserverType, ArgsType>这样写,那么肯定满足不了上面的条件,因为如果定义
CEvent<typename Class1, typename void>那么肯定不满足,上面的条件,这个时间只能被Class1的实例订阅,那怎么办?

一般来说,根据设计模式,总是存异求同.把相同的部分抽取出来.现在的问题在于CEvent和观察者的类型之间有直接的耦合,要消除这个耦合的话,
我的方法就是加间接.在中间再加一个类型CListenerAgent<typename ObserverType, typename ArgsType>,这个类会知道具体的观察者
类型是什么,并且也知道处理时间的函数的类型(返回值都为void)
然后是消除CEvent对观察者类型的依赖,CEvent只需要触发事件,他不关心到底是哪些类型会去处理这个事件,他要做的只是FireEvent.
也就是说CEvent只需要让CListenerAgent去调度具体是哪个类型的实例会处理这个事件,CEvent只需要使用CListenerAgent,但是我们现在看
到的是CListenerAgent也类型相关的,所以必须抽取出一个接口供CEvent使用:IListenerAgent<typename ArgsType>,这个接口只有一个
函数Fire(ArgsType args).CEvent只要依赖于这个接口就OK了.所以CEvent的定义为CEvent<typename ArgsType>;

下面为源代码
template<typename ArgsType>
class IListenerAgent
{
　　public:
　　virtual void Fire(ArgsType) = 0;
};

CListenerAgent<typename ObserverType, typename ArgsType>
{
private:
　　ObserverType* _instance;
public:
　　typedef void (ObserverType::*Delegate)(ArgsType);

　　Delegate Handler;

　　CListenerAgent()
　　{
　　　　Handler = NULL;
　　　　_instance = NULL;
　　}

　　CListenerAgent(ObserverType* i, Delegate h)
　　{
　　　　_instance = i;
　　　　Handler = h;
　　}

　　void Fire(ArgsT ptr)
　　{
 　　(_instance->*Handler)(ptr);
　　}
};

template<typename ArgsType>
class CEvent
{
public:
　　IListenerAgent<ArgsType>* _i;
public:
　　CEvent()
　　{
　　　　_i = NULL;
　　}
　　void operator()(ArgsType args)
　　{
　　　　 if (_i = NULL)
　　　　{
　　　　　　_i->Fire(args);
　　　　}
　　}

　　void operator+=(IListenerAgent<ArgsType>* i)
　　{
　　　　_i = i;
　　}

　　void operator+=(IListenerAgent<ArgsType>* i)
　　{
　　　　_i = NULL;
　　}
};

class Observer1
{
public:
　　void Handler(int)
　　{
　　cout << "Observer1::Handler" << endl;
　　}
};
class Observer2
{
public:
　　void Handler(int)
　　{
　　　　cout << "Observer2::Handler" << endl;
　　}
};

这样基本完成了,那么使用起来就像
Observer1 o1;
Observer2 o2;

CListenerAgent<Observer1, void*>* l1 = new CListenerAgent<Observer1, void*>(&o1, &Observer::Handler);
CListenerAgent<Observer2, void*>* l2 = new CListenerAgent<Observer2, void*>(&o2, &Observer::Handler);

CEvent<int> event;
event += l1;
event += l2;
event(10);

到这里,基本的思想就是这么实现.但是这样还是会有很多问题,比如如果事件注册好,但是还没触发时,o1的实例被销毁了,之后事件触发时则会访问
无效的内存地址而引起严重的错误.

在下一篇文章中我会解决这个问题,代码我已经写好了

转载于:https://www.cnblogs.com/fansoul/p/4603176.html