c++类成员函数作回调

C++类的成员函数作回调函数，主要分三种情况：
1，类的static函数，由于此类函数属于类而非类的实例，不存在this指针的概念，因此可以直接取其函数地址作为回调；
2，类的普通成员函数，这类函数在实现上存在着隐含的this指针，因此作为回调必须指明是哪一个类实例的函数。
3，类的virtual函数,由于存在多态，如果将其作为回调函数，其逻辑上可能会比较复杂，个人觉得应该尽量避免。
以下是C++中类内函数作为回调函数的简单例子：

#include "stdafx.h"
#include <iostream>  
#include <functional>  

using namespace std;
using namespace std::placeholders;

class CallbackWrapper {
public:
    static void static_callback(int a, int b)
    {
        cout << "Static callback() was called!" << endl;
    }

    void callback(int a, int b)
    {
        cout << "callback() was called!" << endl;
    }

    void virtual virtual_callback(int a, int b)
    {
        cout << "virtual callback() was called!" << endl;
    }

};

class CallbackWrapper2 :public CallbackWrapper {

    void virtual_callback(int a, int b)
    {
        cout << "CallbackWrapper2 virtual callback() was called!" << endl;
    }

};

void call_func(int a, int b, std::function<void(int, int)> func)
{
    cout << "call func:";
    func(1, 2);
}

int main()
{
    CallbackWrapper callbackWrapper;
    CallbackWrapper2 callbackWrapper2;

    //static callback
    void(*static_func)(int a, int b);
    static_func = &CallbackWrapper::static_callback;
    static_func(1, 2);
    call_func(1, 2, static_func);
    call_func(1, 2, &CallbackWrapper::static_callback);

    cout << "*********************************" << endl;

    //non static callback
    void(CallbackWrapper::*func)(int a, int b);
    void(CallbackWrapper::*virtual_func)(int a, int b);
    func = &CallbackWrapper::callback;
    virtual_func = &CallbackWrapper::virtual_callback;
    (callbackWrapper.*func)(1, 2);
    //call_func(1, 2, callbackWrapper.*func); //error
    (callbackWrapper2.*virtual_func)(1, 2);
    //call_func(1, 2, callbackWrapper2.*virtual_func); //error

    cout << "*********************************" << endl;

    //C++11 static
    std::function<void(int, int)> static_func_cpp11;
    static_func_cpp11 = std::bind(&CallbackWrapper::static_callback, _1, _2);
    static_func_cpp11(1, 2);
    call_func(1, 2, static_func_cpp11);

    cout << "*********************************" << endl;

    //C++11 non static
    std::function<void(int, int)> func_cpp11;
    func_cpp11 = std::bind(&CallbackWrapper::callback, &callbackWrapper, std::placeholders::_1, std::placeholders::_2);
    func_cpp11(1, 2);
    call_func(1, 2, func_cpp11);

    cout << "*********************************" << endl;
    return 0;
}

运行结果如下：

Static callback() was called!
call func:Static callback() was called!
call func:Static callback() was called!
*********************************
callback() was called!
CallbackWrapper2 virtual callback() was called!
*********************************
Static callback() was called!
call func:Static callback() was called!
*********************************
callback() was called!
call func:callback() was called!
*********************************

从上面可以看出：C++类内函数作为回调可以有新旧两种方式：
1，获取类内函数的函数指针，以此作为回调
2，使用C++ 11的<functinal>,即函数对象
<functional>是C++标准库中的一个头文件，定义了C++标准中多个用于表示函数对象(function object)的类模板，包括算法操作、比较操作、逻辑操作；以及用于绑定函数对象的实参值的绑定器(binder)。这些类模板的实例是具有函数调用运算符(function call operator)的C++类，这些类的实例可以如同函数一样调用。不必写新的函数对象，而仅是组合预定义的函数对象与函数对象适配器(function object adaptor)，就可以执行非常复杂的操作。