cpp的回调函数是一种很有用的办法。比如当接收到数据就需要用回调函数做处理。回调函数用起来通常是这样的
#include <iostream>
//回调函数形式定义
typedef void (* CallBackFunc)(int);
//要使用的回调函数
CallBackFunc g_callBackFunc;
//回调函数注册函数
void register_call_back_function(CallBackFunc func){
g_callBackFunc = func;
}
//测试回调函数使用
void test(){
g_callBackFunc(4);
}
/*用于测试回调函数*/
void custom_function(int a){
std::cout<<"custom function printing number:"<<a<<std::endl;
}
int main(){
register_call_back_function(custom_function);
test();
return 0;
}但是我需要用到在类成员函数作为回调函数的情况。所以我询问了deepseek，它让用现代的编程方式，使用 std::function 和 lambda表达式之类的东西。我不太喜欢新的cpp标准用法。也不会用。它还有提供了一种办法，就是使用静态类成员函数。
这种办法的原理就是储存对象的this指针，回调函数调用的是类的静态函数，在类的静态函数里恢复对象指针，通过对象指针调用它的成员函数。就实现了类成员函数作为回调函数的办法。
根据它提供的方法我写了测试程序，成功运行。
#include <iostream>
//回调函数形式定义
typedef void (* CallBackFunc)(int,void*);
//要使用的回调函数
CallBackFunc g_callBackFunc;
//储存的this指针
void *g_context;
//注册回调函数
void register_call_back_function(CallBackFunc func,void *context){
g_callBackFunc = func;
g_context = context;
}
//测试回调函数使用
void test(){
g_callBackFunc(4,g_context);
}
/*用于测试的类*/
class CA{
public:
virtual ~CA(){}
CA(){}
public:
void class_a_func(int a){
std::cout<<"class a function printing number:"<<a<<std::endl;
}
static void static_class_a_func(int a,void* context){
CA* pThis = static_cast<CA*>(context); // 恢复 `this` 指针
pThis->class_a_func(a);
}
private:
};
//主函数
int main(){
CA ca;
register_call_back_function(CA::static_class_a_func,&ca);
test();
return 0;
}运行结果
class a function printing number:4
或者还可以不储存this指针，绑定类静态成员函数后，在测试使用回调函数时再指定回调函数的对象
#include <iostream>
//回调函数形式定义
typedef void (* CallBackFunc)(int,void*);
//要使用的回调函数
CallBackFunc g_callBackFunc;
//注册回调函数
void register_call_back_function(CallBackFunc func){
g_callBackFunc = func;
}
//测试回调函数使用
void test(void *context){
g_callBackFunc(4,context);
}
/*用于测试的类*/
class CA{
public:
virtual ~CA(){}
CA(){}
public:
void class_a_func(int a){
std::cout<<"class a function printing number:"<<a<<std::endl;
}
static void static_class_a_func(int a,void* context){
CA* pThis = static_cast<CA*>(context); // 恢复 `this` 指针
pThis->class_a_func(a);
}
private:
};
//主函数
int main(){
register_call_back_function(CA::static_class_a_func);
CA ca;
test(&ca);
return 0;
}最后可以把回调函数写入类里，实现面向对象形式的代码
#include <iostream>
//回调函数形式定义
typedef void (* CallBackFunc)(int,void*);
//使用回调函数的类
class CB{
public:
virtual ~CB(){}
CB(){}
public:
//注册回调函数
void register_call_back_function(CallBackFunc func,void *context){
m_callBackFunc = func;
m_context = context;
}
//测试回调函数使用
void test(){
m_callBackFunc(4,m_context);
}
private:
//要使用的回调函数
CallBackFunc m_callBackFunc;
//储存的this指针
void *m_context;
};
/*用于测试的类*/
class CA{
public:
virtual ~CA(){}
CA(){}
public:
void class_a_func(int a){
std::cout<<"class a function printing number:"<<a<<std::endl;
}
static void static_class_a_func(int a,void* context){
CA* pThis = static_cast<CA*>(context); // 恢复 `this` 指针
pThis->class_a_func(a);
}
private:
};
//主函数
int main(){
CA ca;//回调函数对象
CB cb;//使用回调函数的对象
cb.register_call_back_function(CA::static_class_a_func,&ca);//类CA向类CB注册回调函数
cb.test();//测试cb使用ca的回调函数
return 0;
}这样就实现了类成员函数作为回调函数的办法。