c++ 在类中写回调函数

要注意C ++ 的类的成员函数和一般的C 函数的区别。C + + 类采用this 规则传递函数。在使用类的成员函数作为回调函数,要求该成员函数被声名为静态成员函数,并且注意函数声名的时候要同时声明好参数传递规则。

简单的示例：
CallBackClass.h

#ifndef CALL_BACK_CLASS_H
#define CALL_BACK_CLASS_H

class CallBack{
public:
    CallBack(){}
    ~CallBack(){}

    typedef void(*call_back_func)(int);//先声明函数指针，即我们要调用的函数

public:
    /*安装函数指针*/
    void call_back( void(*call_back_func)(int),int n ){
        call_back_func(n);
    }
};
#endif

这里声明及定义写在了一起是为了方便。

main.cpp

#include <iostream>
#include "CallBackClass.h"
using namespace std;

void func(int n){   //该函数需为全局，或类中的静态函数
    cout<<n<<endl;
}

int main()
{
    CallBack a;
    a.call_back_func(func,10);
}

我们调用对象a的成员函数call_back_func，该函数参数为一个函数指针及一个整型。传入函数名即将该函数地址传入，使其调用了func函数。

CallBackTest.h

#ifndef CALL_BACK_TEST_H
#define CALL_BACK_TEST_H

class CallBackTest{
public:
    CallBackTest(){};
    ~CallBackTest(){};

    typedef void(*call_back_func)(void*,int);

public:
    /*绑定对象*/
    void call_back(void* pThisObject,void(*call_back_func)(void*,int),int n){
        my_Object = pThisObject;
        my_func = call_back_func;
        my_n = n;
    }

    void exec_back_func(){
        my_func(my_Object,my_n);//这里将绑定到我们的静态函数
    }
private:
    call_back_func my_func;
    int my_n;
    void* my_Object;
};

#endif

main.cpp

#include <iostream>
#include "CallBackTest.h"
using namespace std;

class Proxy{
public:
    static void need_call_func(void* pCurObject,int n){
        Proxy* pObject = (Proxy*)pCurObject;
        pObject->execFunc(n);
    }

    void Exec(){
        CallBackTest callback;
        callback.call_back(this,need_call_func,10);
        callback.enec_back_func();
    }

    void execFunc(int n){
        cout<<n<<endl;
    }
};

int main()
{
    Proxy test;
    test.Exec();

    return 0;
}

我们都知道，类的静态函数由该类的实例共享。
而这里的疑惑点在于，静态函数的安装。
1、callback.call_back(this,need_call_func,10);确认某个对象的参数
2、callback.exec_back_func();将我们的参数安装到静态函数
3、执行静态函数内容。

其实描述得不是很好，请各位试着自己理解。
对该程序还不是很清楚的 可通过调试才了解程序的执行。