c++委托的实现

/*
 * File:   main.cpp
 * Author: zlh
 * 在c++中实现委托/闭包，实现的效果就是将一个函数变成对象
 * 在mygui的消息响应中就是这种用法
 * 目的很自然，实现却很别扭，委托是c++的软肋之一
 * 一般目标函数不带返回值
 * 该例子的目的是实现4种函数的对象化
 * Created on 2011年8月3日, 下午4:08
 */

#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;

void print0() {
    cout << "无参数，无类型函数\n";
}

void print1(int t) {
    cout << "带参数，无类型函数\n";
}

class A {
public:

    void print2() {
        cout << "无参数，有类型函数\n";
    }

    void print3(int t) {
        cout << "带参数，有类型函数\n";
    }
};

//无参数无类型的函数委托

class Delegate0 {
public:
     //无参数无返回值的函数指针
    typedef void (*FuncPtr)();

    Delegate0(FuncPtr p) {
        ptr = p;
    }

    void execute() {
        ptr();
    }
private:
    FuncPtr ptr;
};

//带一个参数，无类型函数的委托
class Delegate1 {
public:
    //带一个参数无返回值的函数指针
    typedef void (*FuncPtr)(int);

    Delegate1(FuncPtr p, int t) {
        ptr = p;
        param = t;
    }

    void execute() {
        ptr(param);
    }
private:
    FuncPtr ptr;
    int param;
};

/**
 * 无参数，带类型函数的委托
 * 注意带类型的需要做成模板类，在模板参数中指定目标函数的类型
 */

template<class T>
class TypeDelegate0 {
public:
    //不带参数无返回值的成员函数指针，古怪的写法
    typedef void (T::*MemberFuncPtr)();

    TypeDelegate0(T* t, MemberFuncPtr p) {
        mT = t;
        mPtr = p;
    }

    void execute() {
        (mT->*mPtr)();
    }
private:
    T* mT;
    MemberFuncPtr mPtr;
};

//带一个参数，带类型函数的委托

template<class T>
class TypeDelegate1 {
public:
    //带参数无返回值的成员函数指针
    typedef void (T::*MemberFuncPtr)(int);

    TypeDelegate1(T* t, MemberFuncPtr p, int i) {
        mT = t;
        mPtr = p;
        mParam = i;
    }

    void execute() {
        (mT->*mPtr)(mParam);
    }
private:
    T* mT;
    MemberFuncPtr mPtr;
    int mParam;
};

int main(int argc, char* argv[]) {
    //调用void print0()
    Delegate0 d0(print0);
    d0.execute();

    //调用void print1(int i)
    Delegate1 d1(print1, 1);
    d1.execute();

    //调用void A::print2();
    A a1;
    TypeDelegate0<A> d2(&a1, &A::print2);
    d2.execute();

    //调用void A::print3(int i);
    A a2;
    TypeDelegate1<A> d3(&a2, &A::print3, 10);
    d3.execute();
    return 0;
}