1.引言：

上一篇文章已经介绍了如何构建一个无参数无返回值的函数指针的委托,这篇文章将对上一文章所述委托进行扩展，使得可以注册任意函数指针，不过再讲篇内容之前先要介绍一下实现这个功能所需要了解的C++11的一个新特性———可变参数模板。

2.可变参数模板：

             template(模板)是源于将类型和实现(算法)分离开的思想，为了让写好的算法适用于更多类型使得出现了模板，模板使得参数类别任意化，如果再加上“参数个数的任意化”，那么在参数方面的设计手段就基本上齐备了，有了variadic
template
显然可以让设计出来的函数或是类有更大的复用性。因为有很多处理都是与“处理对象的个数”关系不大的，比如说打屏（printf），比如说比较大小（max，min），比如函数绑定子（bind，function要对应各种可能的函数就要能“任意”参数个数和类型）。如果不能对应任意个参数，那么就总会有人无法重用已有的实现，而不得不再重复地写一个自己需要的处理，而共通库的实现者为了尽可能地让自己写的类（函数）能复用在更多的场景，也不得不重复地写很多的代码或是用诡异的技巧，宏之类的去实现有限个“任意参数”的对应。
             所以在C++11中引入了这个新语法，下面我们先看一个例子，了解基本的语法：
  1. template<typename ... Params> class MyClass;
  2. MyClass<int, string> a;

            

 在上面这个例子我们可以看到，在定义和申明中用
typename...
 表示一个参数包，这样我们使用的时候，传入一个<int,string>那么int,string就会被打包入Params中。恩，你可以吧这个参数包看做一个参数的结构体，并且这个结构体的大小是动态的，并且是匿名的。恩，也就是说你无法使用Params[0]这样的语法去随机调用某个类型。听到这里，觉得是匿名的那应该怎么使用呢？答案是递归展开！！！我们先来看一个函数的例子，假如我想写一个Max函数求传入所有参数的最大值，这个参数支持(int,double,float),返回值为double.那么函数原型你觉得大概可能是这样子的：
  1. template<typename ...Params>
  2. double Max(Params... _params)
  3. {
  4. double Maxnum;
  5. //求解过程
  6. return Maxnum;
  7. }

    

     但是这样写你会发现你无法获取到任何传入参数的类型和值。恩，所以我们来看下如何使用递归来获得每个参数的类型和值。
  1. template<typename Head,typename ...Tail>
  2. double Max(Head first,Tail... rest)
  3. {
  4. double Maxnum;
  5. Maxnum = Max(rest...);
  6. if (Maxnum < first)
  7. Maxnum = first;
  8. return Maxnum;
  9. }
     可以看到，我将函数参数分离了一个出来作为Head,这样我就可以每次处理一个变量，使用递归下降，每次递归减少一个参数。注意：上面的rest...表示参数展开，也就是说将这个参数包展开然后当做参数传进去。但是这样做还是不够的，大家都知道递归需要一个出口。所以说我们需要一个重载版本(因为模板函数不能偏特化)。
  1. template<typename Head>
  2. double Max(Head first)
  3. {
  4. return first;
  5. }

     这样就有了一个递归出口了。好，我们结合以上的代码写成一个完整的程序，看下如何使用的：

  1. #include<iostream>
  2. using namespace std;
  3. template<typename Head, typename ...Tail>
  4. double Max(Head first, Tail... rest)
  5. {
  6. double Maxnum=0;
  7. Maxnum = Max(rest...);
  8. if (Maxnum < first)
  9. Maxnum = first;
  10. return Maxnum;
  11. }
  12. template<typename Head>
  13. double Max(Head first)
  14. {
  15. return first;
  16. }
  17. int main()
  18. {
  19. cout << Max(1, 3, 3.4, 5.1, 1.5);
  20. }

     输出结果是： 5.1，同样的，模板类是通过私有继承来实现递归的。
     

  1. template<typename Head, typename... Tail>
  2. class tuple<Head, Tail...> : private tuple<Tail...>{
  3. Head head;
  4. public:
  5. /* implementation */
  6. };
  7. template<typename Head>
  8. class tuple<Head> {
  9. /* one-tuple implementation */
  10. };

     以上可变参数的基本内容就讲完了，如果还有不懂的可以自行百度

3.任意参数个数、返回值任意的函数指针委托：


     同样的，我们还是先对接口进行修改，因为函数指针再不是void(*)(void)所以，接口也需要是一个模板类，而且还需要是一个可变参数模板。
  1. template<typename ReturnType, typename ...ParamType>
  2. class IDelegate
  3. {
  4. public:
  5. IDelegate(){}
  6. virtual ~IDelegate(){}
  7. virtual bool isType(const std::type_info& _type) = 0;
  8. virtual ReturnType invoke(ParamType ... params) = 0;
  9. virtual bool compare(IDelegate<ReturnType, ParamType...> *_delegate) const = 0;
  10. };

     这样，这个接口的invoke函数将会是根据你的函数类型来动态生成对应的模板了。
     同样的，我们把剩下三个类按照如此进行改造:

  1. //StaticDelegate 普通函数的委托
  2. template<typename ReturnType, typename ...ParamType>
  3. class CStaticDelegate :
  4. public IDelegate<ReturnType, ParamType...>
  5. {
  6. public:
  7. typedef  ReturnType(*Func)(ParamType...);
  8. CStaticDelegate(Func _func) : mFunc(_func) { }
  9. virtual bool isType(const std::type_info& _type) { return typeid(CStaticDelegate<ReturnType, ParamType...>) == _type; }
  10. virtual ReturnType invoke(ParamType ... params) { return mFunc(params...); }
  11. virtual bool compare(IDelegate<ReturnType, ParamType ...> *_delegate)const
  12. {
  13. if (0 == _delegate || !_delegate->isType(typeid(CStaticDelegate<ReturnType, ParamType ...>))) return false;
  14. CStaticDelegate<ReturnType, ParamType ...> * cast = static_cast<CStaticDelegate<ReturnType, ParamType ...>*>(_delegate);
  15. return cast->mFunc == mFunc;
  16. }
  17. virtual ~CStaticDelegate(){}
  18. private:
  19. Func mFunc;
  20. };
  21. //成员函数委托
  22. template<typename T, typename ReturnType, typename ...ParamType>
  23. class CMethodDelegate :
  24. public IDelegate<ReturnType, ParamType...>
  25. {
  26. public:
  27. typedef ReturnType(T::*Method)(ParamType...);
  28. CMethodDelegate(T * _object, Method _method) : mObject(_object), mMethod(_method) { }
  29. virtual bool isType(const std::type_info& _type) { return typeid(CMethodDelegate<T, ReturnType, ParamType...>) == _type; }
  30. virtual ReturnType invoke(ParamType...params)
  31. {
  32. (mObject->*mMethod)(params...);
  33. }
  34. virtual bool compare(IDelegate<ReturnType, ParamType...> *_delegate) const
  35. {
  36. if (0 == _delegate || !_delegate->isType(typeid(CMethodDelegate<ReturnType, ParamType...>))) return false;
  37. CMethodDelegate<ReturnType, ParamType...>* cast = static_cast<CMethodDelegate<ReturnType, ParamType...>*>(_delegate);
  38. return cast->mObject == mObject && cast->mMethod == mMethod;
  39. }
  40. CMethodDelegate(){}
  41. virtual ~CMethodDelegate(){}
  42. private:
  43. T * mObject;
  44. Method mMethod;
  45. };
  46. //多播委托
  47. template<typename ReturnType, typename ...ParamType>
  48. class CMultiDelegate
  49. {
  50. public:
  51. typedef std::list<IDelegate<ReturnType, ParamType...>*> ListDelegate;
  52. typedef typename ListDelegate::iterator ListDelegateIterator;
  53. typedef typename ListDelegate::const_iterator ConstListDelegateIterator;
  54. CMultiDelegate() { }
  55. ~CMultiDelegate() { clear(); }
  56. bool empty() const
  57. {
  58. for (ConstListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end(); ++iter)
  59. {
  60. if (*iter) return false;
  61. }
  62. return true;
  63. }
  64. void clear()
  65. {
  66. for (ListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end(); ++iter)
  67. {
  68. if (*iter)
  69. {
  70. delete (*iter);
  71. (*iter) = nullptr;
  72. }
  73. }
  74. }
  75. CMultiDelegate<ReturnType, ParamType...>& operator+=(IDelegate<ReturnType, ParamType...>* _delegate)
  76. {
  77. for (ListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end(); ++iter)
  78. {
  79. if ((*iter) && (*iter)->compare(_delegate))
  80. {
  81. delete _delegate;
  82. return *this;
  83. }
  84. }
  85. mListDelegates.push_back(_delegate);
  86. return *this;
  87. }
  88. CMultiDelegate<ReturnType, ParamType...>& operator-=(IDelegate<ReturnType, ParamType...>* _delegate)
  89. {
  90. for (ListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end(); ++iter)
  91. {
  92. if ((*iter) && (*iter)->compare(_delegate))
  93. {
  94. if ((*iter) != _delegate) delete (*iter);       //避免同一个地址被delete两次
  95. (*iter) = 0;
  96. break;
  97. }
  98. }
  99. delete _delegate;
  100. return *this;
  101. }
  102. std::vector<ReturnType> operator()(ParamType... params)
  103. {
  104. ListDelegateIterator iter = mListDelegates.begin();
  105. std::vector<ReturnType> _Results;
  106. while (iter != mListDelegates.end())
  107. {
  108. if (0 == (*iter))
  109. {
  110. iter = mListDelegates.erase(iter);
  111. }
  112. else
  113. {
  114. _Results.push_back((*iter)->invoke(params...));
  115. ++iter;
  116. }
  117. }
  118. return _Results;
  119. }
  120. private:
  121. CMultiDelegate<ReturnType, ParamType...>(const CMultiDelegate& _event);
  122. CMultiDelegate<ReturnType, ParamType...>& operator=(const CMultiDelegate& _event);
  123. private:
  124. ListDelegate mListDelegates;
  125. };

     但是这样写你会发现你在newDelegate里面对于传来的函数指针进行new
CStaticDelegate或者new
CMethodDelegate的时候需要制定函数返回值、参数的个数和类型，这显然不满足动态类型演化。这时候我们想，能不能给定一个函数指针，让代码自动去识别这个函数的返回值和参数呢？答案是可以的，我们只需要对上面的CStaticDelegate和CMethodDelegate特化一个版本即可。

     这里使用了一个小技巧：通过函数指针去得到函数返回值、参数个数类型。详情可以看看这里：http://bbs.csdn.net/topics/390652170?page=1
     这里我就直接贴我写好的代码：
 
 
  1. //普通函数的委托特化版本
  2. template<typename ReturnType, typename ...ParamType>
  3. class CStaticDelegate<ReturnType(*)(ParamType ...)> :
  4. public IDelegate<ReturnType, ParamType ...>
  5. {
  6. public:
  7. //定义 Func 为 void (void) 函数类型指针。
  8. typedef  ReturnType(*Func)(ParamType...);
  9. CStaticDelegate(Func _func) : mFunc(_func) { }
  10. virtual bool isType(const std::type_info& _type) { return typeid(CStaticDelegate<ReturnType(*)(ParamType ...)>) == _type; }
  11. virtual ReturnType invoke(ParamType ... params) { return mFunc(params...); }
  12. virtual bool compare(IDelegate<ReturnType, ParamType ...> *_delegate)const
  13. {
  14. if (0 == _delegate || !_delegate->isType(typeid(CStaticDelegate<ReturnType(*)(ParamType ...)>))) return false;
  15. CStaticDelegate<ReturnType(*)(ParamType ...)> * cast = static_cast<CStaticDelegate<ReturnType(*)(ParamType ...)>*>(_delegate);
  16. return cast->mFunc == mFunc;
  17. }
  18. virtual ~CStaticDelegate(){}
  19. private:
  20. Func mFunc;
  21. };
  22. //成员函数委托特化
  23. template<typename T, typename ReturnType, typename ...ParamType>
  24. class CMethodDelegate<T,ReturnType (T:: *)(ParamType...)> :
  25. public IDelegate<ReturnType, ParamType...>
  26. {
  27. public:
  28. typedef ReturnType(T::*Method)(ParamType...);
  29. CMethodDelegate(T * _object, Method _method) : mObject(_object), mMethod(_method) { }
  30. virtual bool isType(const std::type_info& _type) { return typeid(CMethodDelegate<T,ReturnType(T:: *)(ParamType...)>) == _type; }
  31. virtual ReturnType invoke(ParamType...params)
  32. {
  33. return (mObject->*mMethod)(params...);
  34. }
  35. virtual bool compare(IDelegate<ReturnType, ParamType...> *_delegate) const
  36. {
  37. if (0 == _delegate || !_delegate->isType(typeid(CMethodDelegate<T, ReturnType(T:: *)(ParamType...)>))) return false;
  38. CMethodDelegate<T, ReturnType(T:: *)(ParamType...)>* cast = static_cast<CMethodDelegate<T, ReturnType(T:: *)(ParamType...)>*>(_delegate);
  39. return cast->mObject == mObject && cast->mMethod == mMethod;
  40. }
  41. CMethodDelegate(){}
  42. virtual ~CMethodDelegate(){}
  43. private:
  44. T * mObject;
  45. Method mMethod;
  46. };

     这样我生成的时候只需要new CStaticDelegate<decltype(Func)>(Func)，而特化版本的可以自动识别这个Func的返回值、参数个数和类型。

     最后我给出newDelegate的代码：
  1. template< typename T>
  2. CStaticDelegate<T>* newDelegate(T func)
  3. {
  4. return new CStaticDelegate<T>(func);
  5. }
  6. template< typename T,typename F>
  7. CMethodDelegate<T,F>* newDelegate(T * _object, F func)
  8. {
  9. return new CMethodDelegate<T, F>(_object, func);
  10. }

     写到这里基本上可变参数的委托就完成了，不过还需要注意一点就是void无返回值类型多播委托需要特殊处理。所以我们还需要一个多播委托对于ReturnType为void这个情况的特化。

  1. template< typename ...ParamType>
  2. class CMultiDelegate<void, ParamType...>
  3. {
  4. public:
  5. typedef std::list<IDelegate<void, ParamType...>*> ListDelegate;
  6. typedef typename ListDelegate::iterator ListDelegateIterator;
  7. typedef typename ListDelegate::const_iterator ConstListDelegateIterator;
  8. CMultiDelegate() { }
  9. ~CMultiDelegate() { clear(); }
  10. bool empty() const
  11. {
  12. for (ConstListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end(); ++iter)
  13. {
  14. if (*iter) return false;
  15. }
  16. return true;
  17. }
  18. void clear()
  19. {
  20. for (ListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end(); ++iter)
  21. {
  22. if (*iter)
  23. {
  24. delete (*iter);
  25. (*iter) = nullptr;
  26. }
  27. }
  28. }
  29. CMultiDelegate<void, ParamType...>& operator+=(IDelegate<void, ParamType...>* _delegate)
  30. {
  31. for (ListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end(); ++iter)
  32. {
  33. if ((*iter) && (*iter)->compare(_delegate))
  34. {
  35. delete _delegate;
  36. return *this;
  37. }
  38. }
  39. mListDelegates.push_back(_delegate);
  40. return *this;
  41. }
  42. CMultiDelegate<void, ParamType...>& operator-=(IDelegate<void, ParamType...>* _delegate)
  43. {
  44. for (ListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end(); ++iter)
  45. {
  46. if ((*iter) && (*iter)->compare(_delegate))
  47. {
  48. if ((*iter) != _delegate) delete (*iter);       //避免同一个地址被delete两次
  49. (*iter) = 0;
  50. break;
  51. }
  52. }
  53. delete _delegate;
  54. return *this;
  55. }
  56. void operator()(ParamType... params)
  57. {
  58. ListDelegateIterator iter = mListDelegates.begin();
  59. while (iter != mListDelegates.end())
  60. {
  61. if (0 == (*iter))
  62. {
  63. iter = mListDelegates.erase(iter);
  64. }
  65. else
  66. {
  67. (*iter)->invoke(params...);
  68. ++iter;
  69. }
  70. }
  71. }
  72. private:
  73. CMultiDelegate<void, ParamType...>(const CMultiDelegate& _event);
  74. CMultiDelegate<void, ParamType...>& operator=(const CMultiDelegate& _event);
  75. private:
  76. ListDelegate mListDelegates;
  77. };

     所有代码都已经贴出来了，我把这些模板全部放到了MyDelegate.h头文件中。下面给一个使用的例子：

  

     

    1. #include "MyDelegate.h"
    2. using namespace Delegate;
    3. void NormalFunc(int a)
    4. {
    5. printf("这里是普通函数 ：%d\n", a);
    6. }
    7. class A
    8. {
    9. public:
    10. static void StaticFunc(int a)
    11. {
    12. printf("这里是成员静态函数 ： %d\n", a);
    13. }
    14. void MemberFunc(int a)
    15. {
    16. printf("这里是成员非静态函数 ： %d\n", a);
    17. }
    18. };
    19. int _tmain(int argc, _TCHAR* argv[])
    20. {
    21. //首先创建了一个返回值为 void ,参数为int 的一个委托。
    22. CMultiDelegate<void, int> e;
    23. //将三个函数注册到该委托中
    24. e += newDelegate(NormalFunc);
    25. e += newDelegate(A::StaticFunc);
    26. e += newDelegate(&A(), &A::MemberFunc);
    27. //调用
    28. e(1);
    29. return 0;
    30. } <strong> </strong>

C++实现委托机制(二)的更多相关文章

  1. C++实现委托机制(一)

    1.引言: 如果你接触过C#,你就会觉得C#中的delegate(委托)十分灵巧,它的用法上和C\C++的函数指针很像,但是却又比C\C++的函数指针更加灵活.并且委托可以一对多,也就是可以注册多个函 ...

  2. Javascript事件模型系列（二）事件的捕获-冒泡机制及事件委托机制

    一.事件的捕获与冒泡 由W3C规定的DOM2标准中,一次事件的完整过程包括三步:捕获→执行目标元素的监听函数→冒泡,在捕获和冒泡阶段,会依次检查途径的每个节点,如果该节点注册了相应的监听函数,则执行监 ...

  3. 【Unity3D技巧】在Unity中使用事件/委托机制（event/delegate）进行GameObject之间的通信 (二) : 引入中间层NotificationCenter

    作者:王选易,出处:http://www.cnblogs.com/neverdie/ 欢迎转载,也请保留这段声明.如果你喜欢这篇文章,请点[推荐].谢谢! 一对多的观察者模式机制有什么缺点? 想要查看 ...

  4. java类加载器学习2——自定义类加载器和父类委托机制带来的问题

    一.自定义类加载器的一般步骤 Java的类加载器自从JDK1.2开始便引入了一条机制叫做父类委托机制.一个类需要被加载的时候,JVM先会调用他的父类加载器进行加载,父类调用父类的父类,一直到顶级类加载 ...

  5. JAVA基础|从Class.forName初始化数据库到SPI破坏双亲委托机制

    代码托管在:https://github.com/fabe2ry/classloaderDemo 初始化数据库 如果你写过操作数据库的程序的话,可能会注意,有的代码会在程序的开头,有Class.for ...

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

    原文来自于http://www.cnblogs.com/netssfy/articles/1652671.html 写了一段时间的C#代码后确实发现C#的事件委托非常好用.于是便想是否在C++中也能如 ...

  7. Java虚拟机JVM学习06 自定义类加载器 父委托机制和命名空间的再讨论

    Java虚拟机JVM学习06 自定义类加载器 父委托机制和命名空间的再讨论 创建用户自定义的类加载器 要创建用户自定义的类加载器,只需要扩展java.lang.ClassLoader类,然后覆盖它的f ...

  8. Java虚拟机JVM学习05 类加载器的父委托机制

    Java虚拟机JVM学习05 类加载器的父委托机制 类加载器 类加载器用来把类加载到Java虚拟机中. 类加载器的类型 有两种类型的类加载器: 1.JVM自带的加载器: 根类加载器(Bootstrap ...

  9. Invoke() 方法是 Unity3D 的一种委托机制

    Invoke() 方法是 Unity3D 的一种委托机制 如: Invoke("SendMsg", 5);   它的意思是:5 秒之后调用 SendMsg() 方法: 使用 Inv ...

随机推荐

  1. LeetCode 16. 3Sum Closest(最接近的三数之和)

    LeetCode 16. 3Sum Closest(最接近的三数之和)

  2. Python内置函数__slots__

    ''' 1.__slots__是什么:是一个类变量,变量值可以是列表,元祖,或者可迭代对象,也可以是一个字符串(意味着所有实例只有一个数据属性) 2.引子:使用点来访问属性本质就是在访问类或者对象的_ ...

  3. 11.6八校联考T1，T2题解

    因为版权问题,不丢题面,不放代码了(出题人姓名也隐藏) T1 这,是一道,DP题,但是我最开始看的时候,我思路挂了,以为是一道简单题,然后就写错了 后来,我正确理解题意后写了个dfs,幸亏没有记忆化, ...

  4. HDU 6215 Brute Force Sorting（模拟链表 思维）

    Brute Force Sorting Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Othe ...

  5. debug id

    id是Eclipse的debugger自己生成的,用于告诉你哪些变量是指向同一个对象:id相同即指向同一个对象. primitive不是对象,所以就没有id. 但是如果你用primitive的wrap ...

  6. trie--- POJ 3764 The xor-longest Path

    The xor-longest Path Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 5453   Accepted: 1 ...

  7. Mac下配置Idea的Maven

    环境版本: Mac OS: 10.13.4 JDK: 1.8 Idea: 2018.3 Maven: 3.6.0 Maven 相关配置: Maven 下载: http://maven.apache.o ...

  8. Codeforces Round #348 (VK Cup 2016 Round 2, Div. 2 Edition) A. Little Artem and Presents 水题

    A. Little Artem and Presents 题目连接: http://www.codeforces.com/contest/669/problem/A Description Littl ...

  9. Unity 的一些特性

    using System; using UnityEngine; using UnityEditor; using UnityEngine.Serialization; using Random = ...

  10. 配置nginx虚拟目录配置文件支持tp的pathinfo

    lnmp自带的包不好用, 经测试,在相应的conf文件加入这句话即可: location / { if (!-e $request_filename) { rewrite ^(.*)$ /index. ...