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

原文地址：点我跳转至原文

写在前面的话：

需要特别注意原文给出的代码是有问题的！！！

原文的主体思路是正确的，他实际上是利用模板的参数推导特性， 将类成员函数从类中剥离开来， 实现委托机制

下面给出我们调试成功的代码：

需要说明的是， 为了调试程序， 我们顺手把所有内容全放到了main.cpp中， 这个风格是不太好的。。。。

#include <iostream>

#include <list>
#include <algorithm>
using namespace std;

/************************************************************************/
/* 基类接口， 用来做 cevent 中做维护的底层list                          */
/************************************************************************/
template<typename ArgsType>
class IListenerAgent
{
public:
virtual void Fire(ArgsType) = 0;
};

/************************************************************************/
/* 用来 剥离类成员函数中的类名部分                                      */
/************************************************************************/
template <typename ObserverType, typename ArgsType>
class CListenerAgent : public IListenerAgent<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(ArgsType ptr)
{
(_instance->*Handler)(ptr);
}
};

/************************************************************************/
/* 委托类                                                               */
/************************************************************************/
template<typename ArgsType>
class CEvent
{
public:
list<IListenerAgent<ArgsType>*> _i;
public:
CEvent(){}

void operator()(ArgsType args)
{
for_each(_i.begin(), _i.end(), [&](IListenerAgent<ArgsType>* item){item->Fire(args); });
}

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

void operator-=(IListenerAgent<ArgsType>* i)
{
for (auto iter = _i.begin(); iter != _i.end(); iter++)
{
if (*iter == i){
_i.erase(iter);
break;
}
}
}
};

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

int main(){

Observer1 o1;
Observer2 o2;

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

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

system("pause");
return 0;
}

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

写了一段时间的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的实例被销毁了,之后事件触发时则会访问

无效的内存地址而引起严重的错误.
在下一篇文章中我会解决这个问题,代码我已经写好了