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 = -1;
        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 = -1;
        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_

 

#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(2, 6);

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

    return 0;
}