C++成员函数如何当作回调函数同时传递this指针

这篇文章主要介绍了C++成员函数如何当作回调函数同时传递this指针，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教

1.普通函数作为注册函数

普通函数作为回调函数，比较简单，只要函数签名（返回值类型+参数类型）一致就可以了。

因为普通函数不是类成员函数，如果想要访问类成员，在执行回调函数的时候，要把对象指针传给回调函数，如下代码：

namespace yy0 { //普通全局函数 void call_back(void* pointer); class A { public: A() { //初始化指针 p_call_back = NULL; //单数最大的数 num = 9; } ~A() {} public: //打印这个数来验证是否正常调用回调函数 int num; private: //指向回调函数的地址的指针 void(*p_call_back)(void*); public: //用于注册回调函数 void register_call_back(void(*p)(void*)) { if (p) p_call_back = p; } //执行回调函数 void run_call_back() { if (p_call_back) { //把对象指针传递出去 p_call_back(this); } } //测试函数 void test() { //注册 register_call_back(call_back); //执行 run_call_back(); } }; void call_back(void* pointer) { if (pointer) { //需要进行指针转换 A* p = (A*)pointer; cout << "打印的值：" << p->num; } } } int main() { yy0::A a; a.test(); getchar(); return 0; }

结果正确打印，说明回调函数正常调用：

也可以定义一个全局的类对象指针：

namespace yy0 { //前置声明 class A; //普通全局函数 void call_back(); //全局的类对象指针 A* pointer = NULL; class A { public: A() { //给全局类对象指针赋值 pointer = this; //初始化指针 p_call_back = NULL; //单数最大的数 num = 9; } ~A() {} public: //打印这个数来验证是否正常调用回调函数 int num; private: //指向回调函数的地址的指针 void(*p_call_back)(); public: //用于注册回调函数 void register_call_back(void(*p)()) { if (p) p_call_back = p; } //执行回调函数 void run_call_back() { if (p_call_back) { //把对象指针传递出去 p_call_back(); } } //测试函数 void test() { //注册 register_call_back(call_back); //执行 run_call_back(); } }; void call_back() { if (pointer) { //需要进行指针转换 A* p = (A*)pointer; cout << "打印的值：" << p->num; } } }

这也可以正确执行，但是这种定义全局的对象指针有风险。如果只创建一个A的对象，就可以正常使用，不会出现什么太大问题。但是，一旦创建的对象个数≥2，那么就造成数据读取错误的问题。

可以想象一下，创建对象a1时，全局对象指针pointer是指向a1的位置，那么读取的pointer->num，是a1对象的num。

然后再创建a2，那么全局对象指针pointer就变成了指向a2的位置（因为pointer是个全局变量，从始至终只有一个这个变量），那么执行a2.text()，pointer->num读取的是a2的num。

如果执行a1.text()，那么此时，pointer->num读取的也是a2的num，而不是a1的num。更严重的是，一旦删除了a1或者a2，就会造成另外一个对象访问内存失败的问题。

2.静态函数作为注册函数

这个就自行上网查看吧，我用的少就不写了。

3.成员函数作为注册函数

假设场景：A类成员函数作为B类回调函数

《深度探索C++对象模型》这本书讲到，类成员函数都有一个隐藏参数用于传递this指针，这个this传递给函数由编译器来完成，不需要用户来做。

直接上代码：

namespace yy3 { class B { public: B() { pointer = NULL; } ~B() {} public: //存放A类的this指针 void* pointer; //指向回调函数 void(__stdcall *pCallBack)(void*); public: /* @函数作用：注册回调 @输入参数： void(*p)(void*)			-- 输入A类的回调函数的地址 void* p_this			-- 输入A类的this指针 */ //② void register_fun(void(__stdcall *p)(void*), void* p_this) { pCallBack = p; pointer = p_this; } //执行回调 //③ void run_call_back() { if (pCallBack) pCallBack(pointer); } }; class A { public: A() { a = 5; } A(int num) { a = num; }; ~A() {} public: //在A类中定义一个B类的变量 B b; //拿来测试的变量 double a; //定义联合，不知道原理，网上查到的技巧 union for_callback { void(__stdcall *fun_int_c)(void*); void (A::*fun_in_class)(void*); }fp; public: //要拿来注册的回调函数 void call_back(void* p) { A* pointer = (A*)p; //能打印出正确的a值就对了 cout << "a:" << pointer->a << endl; } //测试函数 //① void test() { fp.fun_in_class = &A::call_back; b.register_fun(fp.fun_int_c, this); b.run_call_back(); } }; } int main() { yy3::A a; a.test(); getchar(); return 0; }

首先来解释一地方

1.__stdcall声明：这个看情况，我在公司电脑写的时候不需要加这个关键字，自己的电脑就要加这个。就是一个传参约定，可以上网查。

//定义联合，不知道原理，网上查到的技巧 union for_callback { void(__stdcall *fun_int_c)(void*); void (A::*fun_in_class)(void*); }fp;

使用union，这个说是为了逃避编译器检查，原理我也不太懂，如果有知道原理的大神，麻烦告诉一下下，感谢感谢。我直接就拿来用了。

3.前面说了成员函数有个隐含传递指针的参数，所以函数指针：

//指向回调函数 void(__stdcall *pCallBack)(void*);

需要定义参数为void*的函数指针，用于传递A类的this指针

4.因为函数指针是B类的成员，而函数指针接受的参数是A类的this指针，我们不能直接这样使用：

void run_call_back() { if (pCallBack) pCallBack(this); }

这个pCallBack(this)中的this是指向B类对象的地址而非A类对象的地址，因此，在B类定义一个成员：void* pointr，用于保存A类对象的指针，然后这样使用

//执行回调 void run_call_back() { if (pCallBack) pCallBack(pointer); }

这样就运行回调函数，同时传递A类对象指针。

5.（无参这一点单独在这里说）当然，虽然成员函数有自带隐藏参数，我们也可以把它转换成无参的函数，修改这些地方：

//【1】 //指向回调函数 void(__stdcall *pCallBack)(void*); //修改为 void(__stdcall *pCallBack)(); //【2】 void register_fun(void(__stdcall *p)(void*), void* p_this) { pCallBack = p; pointer = p_this; } //修改为 void register_fun(void(__stdcall *p)(), void* p_this) { pCallBack = p; pointer = p_this; } //【3】 //执行回调 void run_call_back() { if (pCallBack) pCallBack(pointer); } //修改为 void run_call_back() { if (pCallBack) pCallBack(); } //【4】 union for_callback { void(__stdcall *fun_int_c)(void*); void (A::*fun_in_class)(void*); }fp; //修改为 union for_callback { void(__stdcall *fun_int_c)(); void (A::*fun_in_class)(); }fp; //【5】 //要拿来注册的回调函数修改为 void call_back() { cout << "a:" << this->a << endl; }

这种情况编译能通过，但是void call_back()使用this指针，是无法正确读取内存的值，如下

言归正传。

成员函数转为带一个void*参数的函数运行情况如下：

结果也是一个不正确的值，因此进行调试查看，把断点放在这个函数上，发现了一个奇怪的问题：

		//要拿来注册的回调函数 void call_back(void* p) { A* pointer = (A*)p; //能打印出正确的a值就对了 cout << "a:" << pointer->a << endl; }

pointer是A类对象的指针，pointer通过函数指针pCallBack(pointr)传递给了call_back(void* p)，从理论上讲，p的值要与pointer保持一致才对。但是p的值与pCaalBack相同，也就是p是函数指针，特别奇怪。我也不知道什么原因，所以如果有人知道，麻烦跟我讲一下，在这里先谢谢了。

我无法解决这个问题，所以尝试了将函数指针转为带有两个void*参数的函数，竟然可以传递正确的this指针，算是瞎猫碰上死耗子，代码跟上面类似，如下：

namespace yy3 { class B { public: B() { pointer = NULL; } ~B() {} public: //存放A类的this指针 void* pointer; //指向回调函数 void(__stdcall *pCallBack)(void*, void*); public: /* @函数作用：注册回调 @输入参数： void(*p)(void*,void*)	-- 输入A类的回调函数的地址 void* p_this			-- 输入A类的this指针 */ void register_fun(void(__stdcall *p)(void*, void*), void* p_this) { pCallBack = p; pointer = p_this; } //执行回调 void run_call_back() { if (pCallBack) //需要两个指针作为参数，干脆就传递两个pointer吧 pCallBack(pointer,pointer); } }; class A { public: A() { a = 5; } A(int num) { a = num; }; ~A() {} public: //在A类中定义一个B类的变量 B b; //拿来测试的变量 double a; //定义联合，不知道原理，网上查到的技巧 union for_callback { void(__stdcall *fun_int_c)(void*, void*); void (A::*fun_in_class)(void*, void*); }fp; public: //要拿来注册的回调函数 void call_back(void* p, void* pp) { A* pointer = (A*)p; //能打印出正确的a值就对了 cout << "a:" << pointer->a << endl; } //测试函数 void test() { fp.fun_in_class = &A::call_back; b.register_fun(fp.fun_int_c, this); b.run_call_back(); } }; }

结果是正确的：