用C++实现C#中的委托和事件

 C#中的测试代码：

using System; namespace testEventApp { public delegate void ClassSender_Event_Handler(object sender, string strEventArg); /// <summary> /// ClassReceiver 的摘要说明。 /// </summary> class ClassReceiver { public ClassReceiver() { Console.WriteLine ("ClassReceiver>>>创建一个ClassReceiver对象！"); } /// <summary> /// 应用程序的主入口点。 /// </summary> [STAThread] static void Main(string[] args) { // // TODO: 在此处添加代码以启动应用程序 // ClassReceiver aClassR = new ClassReceiver (); ClassSender aClassS = new ClassSender (); //将事件处理函数与Class2中的事件关联 aClassS.ClassSender_Event += new ClassSender_Event_Handler(aClassR.On_ClassSenderEvent1); aClassS.ClassSender_Event += new ClassSender_Event_Handler(aClassR.On_ClassSenderEvent2); aClassS.ClassSender_Event += new ClassSender_Event_Handler(On_StaticFun); //调用Class2中的方法，等待其触发事件 aClassS.ClassSender_Event_Riser(); } private void On_ClassSenderEvent1(object sender, string strEventArg) { //ClassSender中事件发生时的处理函数 Console.WriteLine("ClassReceiver On_ClassSenderEvent1>>>收到ClassSender中的事件：" + strEventArg); if (strEventArg == "Cancel1") { ClassSender senderRef = (ClassSender)sender; //取消事件处理函数与ClassSender中事件的关联 senderRef.ClassSender_Event -= new ClassSender_Event_Handler(this.On_ClassSenderEvent1); Console.WriteLine("ClassReceiver On_ClassSenderEvent1>>>不再接收ClassSender的事件！输入exit退出！"); } } private void On_ClassSenderEvent2(object sender, string strEventArg) { Console.WriteLine("ClassReceiver On_ClassSenderEvent2>>收到ClassSender中的事件：" + strEventArg); if (strEventArg == "Cancel2") { ClassSender senderRef = (ClassSender)sender; senderRef.ClassSender_Event -= new ClassSender_Event_Handler(this.On_ClassSenderEvent2); Console.WriteLine("ClassReceiver On_ClassSenderEvent2>>>不再接收ClassSender的事件！输入exit退出！"); } } static void On_StaticFun(object sender, string strEventArg) { Console.WriteLine("On_StaticFun>>收到ClassSender中的事件：" + strEventArg); if (strEventArg == "CancelS") { ClassSender senderRef = (ClassSender)sender; senderRef.ClassSender_Event -= new ClassSender_Event_Handler(On_StaticFun); Console.WriteLine("On_StaticFun>>>不再接收ClassSender的事件！输入exit退出！"); } } } class ClassSender { public ClassSender() { Console.WriteLine ("ClassSender>>>创建一个ClassSender对象！"); } //利用delegate，定义一个事件 public event ClassSender_Event_Handler ClassSender_Event; //一个可以触发事件的方法 public void ClassSender_Event_Riser() { string strRead; while(true) { Console.Write ("ClassSender>>>"); strRead = Console.ReadLine (); if (ClassSender_Event != null)//当事件处理函数存在时 { Console.WriteLine ("ClassSender>>>发送事件："+ strRead); ClassSender_Event(this, strRead);//触发delegate中的事件处理函数 } else if (strRead == "exit") { System.Environment .Exit (-1); } } } } }

 

C++中对应的测试代码：

 #include "stdafx.h" #include <string> #include <iostream> #include <vector> #include <assert.h> #include <afxtempl.h> using namespace std; #include "Event.h" class ClassSender { public: ClassSender() {cout << "ClassSender>>>创建一个ClassSender对象！" << endl;} CEvent<ClassSender*, const string&> ClassSender_Event; void ClassSender_Event_Riser(); }; void ClassSender::ClassSender_Event_Riser() { string strRead; while (true) { cout << "ClassSender>>>"; cin >> strRead; if (ClassSender_Event.GetHandlerCount() != 0) { cout << "ClassSender>>>发送事件：" << strRead << endl; ClassSender_Event(this, strRead); } else if (strRead == "exit") { break; } } } class ClassReceiver { public: ClassReceiver() {cout << "ClassReceiver>>>创建一个ClassReceiver对象！" << endl;} void On_ClassSenderEvent1(ClassSender* sender, const string& strEventArg); void On_ClassSenderEvent2(ClassSender* sender, const string& strEventArg); protected: private: }; void OnStatictFun(ClassSender* sender, const string& strEventArg) { cout << "staitc fun >>> 收到ClassSender中的事件：" << strEventArg << endl; if ("CancelS" == strEventArg) { sender->ClassSender_Event -= CEventHandler<ClassSender*, const string&>(&OnStatictFun); cout << "static fun >>>不再接收ClassSender的事件！输入exit退出！" << endl; } } void ClassReceiver::On_ClassSenderEvent1(ClassSender* sender, const string& strEventArg) { cout << "ClassReceiver On_ClassSenderEvent1>>>收到ClassSender中的事件：" << strEventArg << endl; if ("Cancel1" == strEventArg) { sender->ClassSender_Event -= CEventHandler<ClassSender*, const string&>(this, &ClassReceiver::On_ClassSenderEvent1); cout << "ClassReceiver On_ClassSenderEvent1>>>不再接收ClassSender的事件！输入exit退出！" << endl; } } void ClassReceiver::On_ClassSenderEvent2(ClassSender* sender, const string& strEventArg) { cout << "ClassReceiver On_ClassSenderEvent2>>>收到ClassSender中的事件：" << strEventArg << endl; if ("Cancel2" == strEventArg) { sender->ClassSender_Event -= CEventHandler<ClassSender*, const string&>(this, &ClassReceiver::On_ClassSenderEvent2); cout << "ClassReceiver On_ClassSenderEvent2>>>不再接收ClassSender的事件！输入exit退出！" << endl; } } int _tmain(int argc, _TCHAR* argv[]) { ClassReceiver aClass1; ClassSender aClass2; aClass2.ClassSender_Event += CEventHandler<ClassSender*, const string&>(&aClass1, &ClassReceiver::On_ClassSenderEvent1); aClass2.ClassSender_Event += CEventHandler<ClassSender*, const string&>(&aClass1, &ClassReceiver::On_ClassSenderEvent2); aClass2.ClassSender_Event += CEventHandler<ClassSender*, const string&>(&OnStatictFun); aClass2.ClassSender_Event_Riser(); return 0; }

 

C++中用于实现委托和事件的代码：

/// <summary> /// 委托类型 /// </summary> enum DelegateType { MemberMethod = 1, //成员方法 StaticFunciton = 2, //静态函数 }; /// <summary> /// 委托基础类模板 /// </summary> /// <param name="SenderType"> /// 事件发送者类型 /// </param> /// <param name="ParamType"> /// 事件参数类型 /// </param> template<typename SenderType, typename ParamType> class CDelegate { public: /// <summary> /// 构造函数 /// </summary> CDelegate(){} /// <summary> /// 析构函数 /// </summary> virtual ~CDelegate(){} /// <summary> /// 获得委托类型 /// </summary> /// <returns> /// 委托类型 /// </returns> virtual DelegateType GetType() const= 0; /// <summary> /// 重载操作符，实现委托的调用 /// </summary> /// <param name="sender"> /// 事件发送者对象 /// </param> /// <param name="param"> /// 事件参数 /// </param> virtual void operator()(SenderType sender, ParamType param) = 0; /// <summary> /// 比较两个委托是否相等 /// </summary> /// <param name="srcDelegate"> /// 被比较的源委托对象 /// </param> virtual bool operator==(const CDelegate& srcDelegate) = 0; /// <summary> /// 克隆委托对象 /// </summary> /// <returns> /// 克隆后的新对象 /// </returns> virtual CDelegate* Clone() = 0; }; /// <summary> /// 成员方法委托模板 /// </summary> /// <param name="PointerToObj"> /// 事件接收者对象类型 /// </param> /// <param name="PointerToMemMethod"> /// 事件接收者成员函数 /// </param> /// <param name="SenderType"> /// 事件发送者类型 /// </param> /// <param name="ParamType"> /// 事件参数类型 /// </param> template<typename PointerToObj, typename PointerToMemMethod, typename SenderType, typename ParamType> class CMemberMethodDelegate : public CDelegate<SenderType, ParamType> { public: typedef CMemberMethodDelegate<PointerToObj, PointerToMemMethod, SenderType, ParamType> This_Type; /// <summary> /// 构造函数 /// </summary> /// <param name="pObj"> /// 事件接收者对象 /// </param> /// <param name="pMemFn"> /// 事件接收者成员函数 /// </param> CMemberMethodDelegate(const PointerToObj& pObj, PointerToMemMethod pMemFn) : m_pReceiverObject(pObj), m_pReceiverMemberMethod(pMemFn) { } /// <summary> /// 获得委托类型 /// </summary> /// <returns> /// 委托类型 /// </returns> DelegateType GetType() const { return MemberMethod; } /// <summary> /// 重载操作符，实现事件委托调用 /// </summary> /// <param name="sender"> /// 事件发送者对象 /// </param> /// <param name="param"> /// 事件参数 /// </param> virtual void operator()(SenderType sender, ParamType param) { ((*m_pReceiverObject).*m_pReceiverMemberMethod)(sender, param); } /// <summary> /// 克隆委托对象 /// </summary> /// <returns> /// 克隆后的新对象 /// </returns> CMemberMethodDelegate* Clone() { return new CMemberMethodDelegate<PointerToObj, PointerToMemMethod, SenderType, ParamType>(m_pReceiverObject, m_pReceiverMemberMethod); } /// <summary> /// 比较两个委托是否相等 /// </summary> /// <param name="srcDelegate"> /// 被比较的源委托对象 /// </param> bool operator==(const CDelegate& srcDelegate) { if(srcDelegate.GetType() != MemberMethod) { return false; } const This_Type& rFun = dynamic_cast<const This_Type&>(srcDelegate); return (m_pReceiverObject == rFun.m_pReceiverObject && m_pReceiverMemberMethod == rFun.m_pReceiverMemberMethod); } protected: PointerToObj m_pReceiverObject; //事件接收者对象 PointerToMemMethod m_pReceiverMemberMethod; //事件接收类成员方法 }; /// <summary> /// 静态函数或者全局函数委托模板 /// </summary> /// <param name="Func"> /// 函数类型 /// </param> /// <param name="SenderType"> /// 事件发送者类型 /// </param> /// <param name="ParamType"> /// 事件参数类型 /// </param> template <typename Func, typename SenderType, typename ParamType> class CStaticFunctionDelegate : public CDelegate<SenderType, ParamType> { public: /// <summary> /// 构造函数 /// </summary> /// <param name="func"> /// 函数指针 /// </param> CStaticFunctionDelegate(const Func& func) : m_function(func){}; /// <summary> /// 析构函数 /// </summary> virtual ~CStaticFunctionDelegate(){} /// <summary> /// 获得内部委托类型 /// </summary> /// <returns> /// 内部委托类型 /// </returns> DelegateType GetType() const { return StaticFunciton; } /// <summary> /// 重载操作符，实现事件委托调用 /// </summary> /// <param name="sender"> /// 事件发送者对象 /// </param> /// <param name="param"> /// 事件参数 /// </param> void operator()(SenderType sender, ParamType param) { (*m_function)(sender, param); } /// <summary> /// 克隆委托对象 /// </summary> /// <returns> /// 克隆后的新对象 /// </returns> CDelegate<SenderType, ParamType>* Clone() { return new CStaticFunctionDelegate<Func, SenderType, ParamType>(m_function); } /// <summary> /// 比较两个委托是否相等 /// </summary> /// <param name="srcDelegate"> /// 被比较的源委托对象 /// </param> bool operator==(const CDelegate<SenderType, ParamType>& fun) { if(fun.GetType() != StaticFunciton) { return false; } const CStaticFunctionDelegate<Func, SenderType, ParamType>& rFun = dynamic_cast<const CStaticFunctionDelegate<Func, SenderType, ParamType>& >(fun); return m_function == rFun.m_function; } protected: Func m_function; }; /// <summary> /// 事件委托处理类 /// </summary> /// <param name="SenderType"> /// 事件发送者类型 /// </param> /// <param name="ParamType"> /// 事件参数类型 /// </param> template<typename SenderType, typename ParamType> class CEventHandler { public: /// <summary> /// 构造函数 /// </summary> CEventHandler() : m_pDelegate(NULL) { } /// <summary> /// 析构函数 /// </summary> virtual ~CEventHandler() { Clear(); } /// <summary> /// 构造函数 /// </summary> /// <param name="Function"> /// 接收函数类型 /// </param> template <typename Function> CEventHandler(const Function& func) : m_pDelegate(new CStaticFunctionDelegate<Function, SenderType, ParamType>(func)) { } /// <summary> /// 构造函数 /// </summary> /// <param name="PointerToObj"> /// 接收者对象类型 /// </param> /// <param name="PointerToMemFun"> /// 接收类成员方法 /// </param> template <typename PointerToObj, typename PointerToMemFun> CEventHandler(const PointerToObj& pObj, const PointerToMemFun& pMemFun) : m_pDelegate(new CMemberMethodDelegate<PointerToObj, PointerToMemFun, SenderType, ParamType >(pObj, pMemFun)) {} /// <summary> /// 拷贝构造函数 /// </summary> CEventHandler(const CEventHandler<SenderType, ParamType>& eventHandler) : m_pDelegate(NULL) { *this = eventHandler; } /// <summary> /// 赋值操作符重载 /// </summary> CEventHandler& operator=(const CEventHandler<SenderType, ParamType>& eventHandler) { Clear(); if (eventHandler.m_pDelegate) { m_pDelegate = eventHandler.m_pDelegate->Clone(); } return *this; } /// <summary> /// 事件委托调用 /// </summary> /// <param name="sender"> /// 事件发送者对象 /// </param> /// <param name="param"> /// 事件参数 /// </param> void operator()(SenderType sender, ParamType param) { if (m_pDelegate) { (*m_pDelegate)(sender, param); } } /// <summary> /// 比较两个事件处理器是否相同 /// </summary> /// <param name="srcHandler"> /// 比较源 /// </param> bool operator==(const CEventHandler<SenderType, ParamType>& srcHandler) { if (m_pDelegate == NULL || srcHandler.m_pDelegate == NULL) { return true; } if(m_pDelegate->GetType() == srcHandler.m_pDelegate->GetType()) { return (*m_pDelegate) == (*(srcHandler.m_pDelegate)); } return false; } /// <summary> /// 清除内部对象 /// </summary> void Clear() { if (m_pDelegate) { delete m_pDelegate; m_pDelegate = NULL; } } protected: CDelegate<SenderType, ParamType>* m_pDelegate;//委托对象指针 }; /// <summary> /// 事件接口模板 /// </summary> /// <param name="SenderType"> /// 事件发送者类型 /// </param> /// <param name="ParamType"> /// 事件参数类型 /// </param> template<typename SenderType, typename ParamType> struct IEvent { /// <summary> /// 注册事件处理对象 /// </summary> /// <param name="handler"> /// 事件处理对象 /// </param> virtual void Register(const CEventHandler<SenderType, ParamType>& handler) = 0; /// <summary> /// 注销事件处理对象 /// </summary> /// <param name="handler"> /// 事件处理对象 /// </param> virtual void UnRegister(const CEventHandler<SenderType, ParamType>& handler) = 0; /// <summary> /// 触发事件委托 /// </summary> /// <param name="SenderType"> /// 事件发送者对象 /// </param> /// <param name="ParamType"> /// 事件参数 /// </param> virtual void Fire(SenderType sender, ParamType param) = 0; /// <summary> /// 获得事件处理者个数 /// </summary> /// <returns> /// 事件处理者个数 /// </returns> virtual int GetHandlerCount() = 0; /// <summary> /// 获得特定索引的事件处理者对象 /// </summary> /// <param name="nIndex"> /// 索引 /// </param> /// <returns> /// 事件处理者对象 /// </returns> virtual const CEventHandler<SenderType, ParamType>& GetHandlerAt(const int nIndex) = 0; }; /// <summary> /// 事件实现类模板 /// </summary> /// <param name="SenderType"> /// 事件发送者类型 /// </param> /// <param name="ParamType"> /// 事件参数类型 /// </param> template<typename SenderType, typename ParamType> class CEvent : public IEvent<SenderType, ParamType> { public: /// <summary> /// 构造函数 /// </summary> CEvent() { } /// <summary> /// 析构函数 /// </summary> virtual ~CEvent() { m_handerArray.RemoveAll(); } public: /// <summary> /// 重载操作符，触发事件委托 /// </summary> /// <param name="SenderType"> /// 事件发送者对象 /// </param> /// <param name="ParamType"> /// 事件参数 /// </param> void operator()(SenderType sender, ParamType param) { Fire(sender, param); } /// <summary> /// 触发事件委托 /// </summary> /// <param name="SenderType"> /// 事件发送者对象 /// </param> /// <param name="ParamType"> /// 事件参数 /// </param> void Fire(SenderType sender, ParamType param) { CArray<CEventHandler<SenderType, ParamType> > handlers; handlers.Append(m_handerArray);//放到另一数组里，以免原数组在调用过程中有变化 int nCount = (int)handlers.GetSize(); for(int i = 0; i < nCount; i++) { CEventHandler<SenderType, ParamType> eventHandler = handlers.GetAt(i); eventHandler(sender, param); } } /// <summary> /// 获得事件处理者个数 /// </summary> /// <returns> /// 事件处理者个数 /// </returns> int GetHandlerCount() { return (int)m_handerArray.GetCount(); } /// <summary> /// 获得特定索引的事件处理者对象 /// </summary> /// <param name="nIndex"> /// 索引 /// </param> /// <returns> /// 事件处理者对象 /// </returns> const CEventHandler<SenderType, ParamType>& GetHandlerAt(const int nIndex) { assert((nIndex >= 0) && (nIndex < (int)m_handerArray.GetCount())); return m_handerArray.GetAt(nIndex); } /// <summary> /// 重载操作符，注册事件处理对象 /// </summary> /// <param name="handler"> /// 事件处理对象 /// </param> CEvent& operator+= (const CEventHandler<SenderType, ParamType>& handler) { Register(handler); return *this; } /// <summary> /// 重载操作符，注销事件处理对象 /// </summary> /// <param name="handler"> /// 事件处理对象 /// </param> CEvent& operator-= (const CEventHandler<SenderType, ParamType>& handler) { UnRegister(handler); return *this; } /// <summary> /// 注册事件处理对象 /// </summary> /// <param name="handler"> /// 事件处理对象 /// </param> void Register(const CEventHandler<SenderType, ParamType>& handler) { m_handerArray.Add(handler); } /// <summary> /// 注销事件处理对象 /// </summary> /// <param name="handler"> /// 事件处理对象 /// </param> void UnRegister(const CEventHandler<SenderType, ParamType>& handler) { int nCount = (int)m_handerArray.GetCount(); for(int i = 0; i < nCount; i++) { CEventHandler<SenderType, ParamType> eventHandler = m_handerArray.GetAt(i); if(eventHandler == handler) { m_handerArray.RemoveAt(i); return; } } } private: CArray<CEventHandler<SenderType, ParamType> > m_handerArray;//事件处理对象列表 };