如何让成员函数可以成为回调函数?

Incawang 2006-01-05 08:44:19

如何让成员函数可以成为回调函数?

我想写一个函数,它的一个参数可以是任何类的一个成员函数,但是格式相同,如:

class classA
{
void add(int n)
{
}
}

class classB
{
void sub(int n)
{
}
}

MyFunction(xxxx a);

这里的函数指针xxxx如何定义才能适用于上面两个没有关系的类的两个成员函数呢?

...全文

741 17 打赏收藏转发到动态举报

写回复

用AI写文章

17 条回复

切换为时间正序

请发表友善的回复…

发表回复

sinall 2006-01-06

打赏
举报

vollin(林尚义)不错。
不过似乎不需要boost，stl就可以搞定了。

//#include <boost/bind.hpp>
#include <iostream>
#include <functional>
using namespace std;
struct classA
{
void add(int n)
{
cout<<"add:"<<n<<endl;
}
};

struct classB
{
void sub(int n)
{
cout<<"sub:"<<n<<endl;
}
};

template<class _Fun>
void MyFunction(_Fun a,int n)
{
a(n);
}

int main()
{
classA a;
classB b;
MyFunction(bind1st(mem_fun(&classA::add),&a),10);
MyFunction(bind1st(mem_fun(&classB::sub),&b),19);
return 0;
}

iamcaicainiao 2006-01-06

打赏
举报

学习，顶道士。

vollin 2006-01-06

打赏
举报

如果参数不是引用的话，用stl是不会出问题的，但如果是引用的话就只能boost了。
要不然就会推导出一个引用的引用从而产生错误。

hu_vane 2006-01-06

打赏
举报

mark

vollin 2006-01-05

打赏
举报

一个示例：
#include <boost/bind.hpp>
#include <iostream>
using namespace std;
struct classA
{
void add(int n)
{
cout<<"add:"<<n<<endl;
}
};

struct classB
{
void sub(int n)
{
cout<<"sub:"<<n<<endl;
}
};

template<class _Fun>
void MyFunction(_Fun a,int n)
{
a(n);
}

int main()
{
classA a;
classB b;
MyFunction(boost::bind(boost::mem_fn(&classA::add),&a,_1),10);
MyFunction(boost::bind(boost::mem_fn(&classB::sub),&b,_1),19);
return 0;
}

运行结果：
add:10
sub:19

guyanhun 2006-01-05

打赏
举报

学习！

wshcdr 2006-01-05

打赏
举报

试试类函数指针

vollin 2006-01-05

打赏
举报

听说过函数对象吗？如果听说过的话就一定知道如何将一个成员函数变成函数对象，
当然这个在stl中有些麻烦mem_fun,mem_fun_ref，但如果使用boost的话就非常之简单。看一下boost::mem_fn吧
看完就可以用了。

当然你也完全可以自己实现，那就是使用成员指针，不过我看过一些相关的文档，需要利用一些
编译器的漏洞才可以简单的实现，要不然就要学习一下mem_fn（）的编写方法。

foochow 2006-01-05

打赏
举报

难得见道士出来灌啊...

sankt 2006-01-05

打赏
举报

学习

sinall 2006-01-05

打赏
举报

3、函数对象的方法。
#include<iostream>
using namespace std;

class base
{
public:
virtual void a() = 0;
};

class A : public base
{
public:
void a()
{
cout<<"A::a()"<<endl;
}
static void a1()
{
cout<<"A::a1()"<<endl;
}
};
class B : public base
{
public:
void a()
{
cout<<"B::b()"<<endl;
}
static void a1()
{
cout<<"A::a1()"<<endl;
}
};

void MyFunc(base* b)
"recall.cpp" 58 行，541 字符
{
public:
void a()
{
cout<<"A::a()"<<endl;
}
static void a1()
{
cout<<"A::a1()"<<endl;
}
};
class B : public base
{
#include<iostream>
using namespace std;

class base
{
public:
virtual void a() = 0;
};

class A : public base
{
public:
void a()
{
cout<<"A::a()"<<endl;
}
static void a1()
{
cout<<"A::a1()"<<endl;
}
};
class B : public base
{
public:
void a()
{
cout<<"B::b()"<<endl;
}
static void a1()
{
cout<<"B::a1()"<<endl;
}
};

void MyFunc(base* b)
{
b->a();
}

template< typename T >
struct MyFunc1
{
void operator()()
{
T::a1();
}
};

int main()
{
A a;
B b;
MyFunc(&a);
MyFunc(&b);
MyFunc1<A>()();
MyFunc1<B>()();
}

sinall 2006-01-05

打赏
举报

1、“模板”的方法，如Eastunfail(龍子龍孫)所说。
2、“接口”——“纯虚基类”的方法。
#include<iostream>
using namespace std;

class base
{
public:
virtual void a() = 0;
};

class A : public base
{
public:
void a()
{
cout<<"A::a()"<<endl;
}
};
class B : public base
{
public:
void a()
{
cout<<"B::b()"<<endl;
}
};

void MyFunc(base* b)
{
b->a();
}

int main()
{
A a;
B b;
MyFunc(&a);
MyFunc(&b);
}

Eastunfail 2006-01-05

打赏
举报

或者让A和B都从一个类继承下来。定义回调函数：
void (C::*Method)(int);
这里假设A和B都从C继承下来

zhouhuahai 2006-01-05

打赏
举报

如果试图直接使用C++的成员函数作为回调函数将发生错误，甚至编译就不能通过。通过查询资料发现，其错误是普通的C++成员函数都隐含了一个传递函数作为参数，亦即“this”指针，C++通过传递一个指向自身的指针给其成员函数从而实现程序函数可以访问C++的数据成员。这也可以理解为什么C++类的多个实例可以共享成员函数但是确有不同的数据成员。由于this指针的作用，使得将一个CALLBACK型的成员函数作为回调函数安装时就会因为隐含的this指针使得函数参数个数不匹配，从而导致回调函数安装失败。要解决这一问题的关键就是不让this指针起作用，通过采用以下两种典型技术可以解决在C++中使用回调函数所遇到的问题。这种方法具有通用性，适合于任何C++。

　　1). 不使用成员函数，直接使用普通C函数，为了实现在C函数中可以访问类的成员变量，可以使用友元操作符(friend)，在C++中将该C函数说明为类的友元即可。这种处理机制与普通的C编程中使用回调函数一样。

　　2). 使用静态成员函数，静态成员函数不使用this指针作为隐含参数，这样就可以作为回调函数了。静态成员函数具有两大特点：其一，可以在没有类实例的情况下使用；其二，只能访问静态成员变量和静态成员函数，不能访问非静态成员变量和非静态成员函数。由于在C++中使用类成员函数作为回调函数的目的就是为了访问所有的成员变量和成员函数，如果作不到这一点将不具有实际意义。解决的办法也很简单，就是使用一个静态类指针作为类成员，通过在类创建时初始化该静态指针，如pThis=this，然后在回调函数中通过该静态指针就可以访问所有成员变量和成员函数了。这种处理办法适用于只有一个类实例的情况，因为多个类实例将共享静态类成员和静态成员函数，这就导致静态指针指向最后创建的类实例。为了避免这种情况，可以使用回调函数的一个参数来传递this指针，从而实现数据成员共享。这种方法稍稍麻烦，这里就不再赘述。

Eastunfail 2006-01-05

打赏
举报

#include<iostream>
using namespace std;
class A
{
public:
void a()
{
cout<<"A::a()"<<endl;
}
};
class B
{
public:
void b()
{
cout<<"B::b()"<<endl;
}
};

template<class T>
void MyFunc(T*inst,void (T::*aa)())
{
(inst->*aa)();
}

void main()
{
A a;
B b;
MyFunc(&a,&A::a);
MyFunc(&b,&B::b);
}

模版的方法

zhouhuahai 2006-01-05