C++ 0x 使用可变参数模板类 实现 C# 的委托机制

 #ifndef _ZTC_DELEGATE_H_
 #define _ZTC_DELEGATE_H_

 #include <vector>
 #include <functional>

 ///////////////////////////////////////////////
 // C++ 使用 可变参数模板类, 来实现
 // C#中的 委托
 // Anchor: ztc
 // Date  : 2014-01-10
 ///////////////////////////////////////////////

 template<typename R, typename ...Args>
 class Delegate {
 public:
     template<typename U>
     Delegate& operator += (const U &func) {
         funcList.push_back(std::function<R(Args...)>(func));
         funcPointers.push_back((void*)&func);
         return *this;
     }

     template<typename U>
     Delegate& operator -= (const U &func) {
         int i = -;
         for (auto iter = funcPointers.begin(); iter != funcPointers.end(); iter++) {
             i++;
             if (*iter == (void*)&func) {
                 funcPointers.erase(iter);
                 funcList.erase(funcList.begin() + i);
                 break;
             }
         }
         return *this;
     }

     std::vector<R> operator()(Args...args) {
         std::vector<R> ret;
         for (auto f : funcList) {
             ret.push_back(f(args...));
         }
         return ret;
     }
 private:
     std::vector<std::function<R(Args...)>> funcList;
     std::vector<void*> funcPointers;
 };

 template<typename ...Args>
 class Delegate<void, Args...>  {
 public:
     template<typename U>
     Delegate& operator += (const U &func) {
         std::cout << "注册方法 " << typeid(func).name() << std::endl;
         funcList.push_back(std::function<void(Args...)>(func));
         funcPointers.push_back((void*)&func);
         return *this;
     }

     template<typename U>
     Delegate& operator -= (const U &func) {
         std::cout << "卸载方法 " << typeid(func).name() << std::endl;
         int i = -;
         for (auto iter = funcPointers.begin(); iter != funcPointers.end(); iter++) {
             i++;
             if (*iter == (void*)&func) {
                 funcPointers.erase(iter);
                 funcList.erase(funcList.begin() + i);
                 break;
             }
         }
         return *this;
     }

     void operator() (Args... args) {
         for (auto f : funcList) {
             f(args...);
         }
     }
 private:
     std::vector<std::function<void(Args...)>> funcList;
     std::vector<void*> funcPointers;
 };

 #endif // _ZTC_DELEGATE_H_

ztc_Delegate.hpp

 #include <iostream>
 #include "ztc_Delegate.hpp"

　　// 普通函数
 int foo(int a, int b) {
     return a * a + b * b;
 }

　　// 普通无参无返回函数
 void kaoo() {
     std::cout << "kaooooooo" << std::endl;
 }
 void kaoo2() {
     std::cout << "kaooooo22222oo" << std::endl;
 }

　　// 类成员函数
 class Test {
 public:
     void funcInClass() {
         std::cout << "Function In Class" << std::endl;
     }
 };

 int main() {
     // 定义事件 有返回值
     Delegate<int, int, int> OnSomething;
     // 定义事件 无返回值
     Delegate<void> OnKao;

     // 注册方法
     OnSomething += [](int a, int b) {return a + b; };
     OnSomething += [](int a, int b) {return a * b; };
     OnSomething += foo;

     // 类的成员函数 需要 使用 Bind
     Test c;
     auto cf = std::bind(&Test::funcInClass, c);

     // 注册类成员函数
     OnKao += cf;
     // 注册普通函数
     OnKao += kaoo;
     OnKao += kaoo2;
     // 调用事件
     OnKao();
     // 卸载类成员函数
     OnKao -= cf;
     // 制裁普通函数
     OnKao -= kaoo;
     // 调用方法
     OnKao();

     // 调用事件 得到 结果
     auto ret = OnSomething(, );

     // 显示结果
     for (auto r : ret) {
         std::cout << r << std::endl;
     }

     return ;
 }