关于c ++：回调到非静态方法

Callback to non-static method

想想你的基本暴饮计划。它们只是从一个主方法运行，并包含像'glutmousefunc(mousebutton)这样的回调，其中mousebutton是一个方法的名称。

我所做的是将主文件封装到一个类中，这样mouseButton就不再是一个静态函数，而是有一个实例。但是这样做会给我一个编译错误：

Error 2 error C3867: 'StartHand::MouseButton': function call missing argument list; use '&StartHand::MouseButton' to create a pointer to member c:\users\angeleyes\documents\visual studio 2008\projects\capstone ver 4\starthand.cpp 388 IK Engine

号

由于类很大，所以不可能提供代码示例。

我试过使用this->MouseButton，但也有同样的错误。不能为回调提供指向实例函数的指针吗？

相关讨论

正如错误消息所说，您必须使用&StartHand::MouseButton语法来获取指向成员函数(ptmf)的指针；这只是语言的一部分。

在使用ptmf时，您调用的函数glutmousefunc(在本例中为glutmousefunc)也必须期望得到一个ptmf作为回调，否则使用非静态mousebutton将不起作用。相反，一种常见的技术是回调使用用户提供的void*上下文，该上下文可以是实例指针&mdash；，但执行回调的库必须显式允许此参数。确保与外部库(下面的handle_mouse函数)预期的ABI匹配也很重要。

由于glut不允许用户提供上下文，因此必须使用另一种机制：将对象与glut的当前窗口关联。不过，它确实提供了一种获取"当前窗口"的方法，我使用它将void*与窗口关联起来。然后您只需要创建一个蹦床来进行类型转换并调用该方法。

机械：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <map>

int glutGetWindow() { return 0; } // make this example compile and run ##E##

typedef std::pair<void*, void (*)(void*,int,int,int,int)> MouseCallback;
typedef std::map<int, MouseCallback> MouseCallbacks;
MouseCallbacks mouse_callbacks;
extern"C" void handle_mouse(int button, int state, int x, int y) {
MouseCallbacks::iterator i = mouse_callbacks.find(glutGetWindow());
if (i != mouse_callbacks.end()) { // should always be true, but possibly not
// if deregistering and events arrive
i->second.second(i->second.first, button, state, x, y);
}
}

void set_mousefunc(
MouseCallback::first_type obj,
MouseCallback::second_type f
) {
assert(obj); // preconditions
assert(f);
mouse_callbacks[glutGetWindow()] = MouseCallback(obj, f);
//glutMouseFunc(handle_mouse); // uncomment in non-example ##E##
handle_mouse(0, 0, 0, 0); // pretend it's triggered immediately ##E##
}

void unset_mousefunc() {
MouseCallbacks::iterator i = mouse_callbacks.find(glutGetWindow());
if (i != mouse_callbacks.end()) {
mouse_callbacks.erase(i);
//glutMouseFunc(0); // uncomment in non-example ##E##
}
}

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include <iostream>

struct Example {
void MouseButton(int button, int state, int x, int y) {
std::cout <<"callback
";
}
static void MouseButtonCallback(
void* self, int button, int state, int x, int y
) {
static_cast<Example*>(self)->MouseButton(button, state, x, y);
}
};

int main() {
Example obj;
set_mousefunc(&obj, &Example::MouseButtonCallback);

return 0;
}

注意，您不再直接调用glutmousefunc；它是作为[un]set_mousefunc的一部分管理的。

以防万一不清楚：我已经重写了这个答案，所以它应该为你工作，从而避免了C/C++链接问题的争论。它将按原样编译和运行(不带GLU)，并且应该只对GLU进行少量修改：对标记为##E##的4行进行注释或取消注释。

相关讨论

不，不能将指向实例函数的指针赋给需要某个签名的函数指针的回调函数。他们的签名不同。它无法编译。

通常，这样的API允许您在void*中作为"context"参数传递。在那里传递对象，并编写一个包装函数，该函数将上下文作为回调。包装器将它强制转换回您使用的任何类，并调用适当的成员函数。

与所有人似乎都在说的相反，您最肯定可以使用非静态成员函数作为回调方法。它需要专门为获取指向非静态成员的指针而设计的特殊语法，以及在类的特定实例上调用该函数的特殊语法。有关所需语法的讨论，请参阅此处。

下面是示例代码，说明了这是如何工作的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

#include <cstdlib>
#include <string>
#include <iostream>
#include <vector>
#include <sstream>
#include
using namespace std;

class Operational
{
public:
Operational(int value) : value_(value) {};

string FormatValue() const ;

private:
int value_;

};

string Operational::FormatValue() const
{
stringstream ss;
ss <<"My value is" << value_;
return ss.str();
}

typedef string(Operational::*FormatFn)() const; // note the funky syntax

Operational make_oper(int val)
{
return Operational(val);
}

int main()
{
// build the list of objects with the instance callbacks we want to call
Operational ops[] = {1, 2, 3, 5, 8, 13};
size_t numOps = sizeof(ops)/sizeof(ops[0]);

// now call the instance callbacks
for( size_t i = 0; i < numOps; ++i )
{
// get the function pointer
FormatFn fn = &Operational::FormatValue;

// get a pointer to the instance
Operational* op = &ops[i];

// call the callback on the instance
string retval = (op->*fn)();

// display the output
cout <<"The object @" << hex << (void*)op <<" said: '" << retval <<"'" << endl;
}

return 0;
}

当我在我的机器上运行这个程序时，它的输出是：

1
2
3
4
5
6

The object @ 0017F938 said: 'My value is 1'
The object @ 0017F93C said: 'My value is 2'
The object @ 0017F940 said: 'My value is 3'
The object @ 0017F944 said: 'My value is 5'
The object @ 0017F948 said: 'My value is 8'
The object @ 0017F94C said: 'My value is 13'

相关讨论

不能用实例回调替换静态回调。当调用者调用您的回调时，它调用的是哪个实例？换句话说，调用者如何传递正式的"this"参数？

解决方案是使用静态回调存根并将实例作为参数传递，这意味着被调用方必须接受在调用回调时将返回的任意pvoid。在存根中，然后可以调用非静态方法：

1
2
3
4
5
6
7
8
9
10

class C {
void f() {...}
static void F(void* p) {
C* pC = (C*)p;
pC->f();
}
}

C* pC = ...;
someComponent.setCallback(&C::F, pC);

下面的工作在C++中定义了一个C回调函数，例如在使用GLUT(GaldStupFunc，GLUKEKBOADFUNC，GLUMUSEFUNC…)时，只需要一个实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

MyClass * ptr_global_instance = NULL;

extern"C" void mouse_buttons_callback(int button, int state, int x, int y) {

// c function call which calls your c++ class method

ptr_global_instance->mouse_buttons_cb(button, state, x, y);
}

void MyClass::mouse_buttons_cb(int button, int state, int x, int y) {

// this is actual body of callback - ie. if (button == GLUT_LEFT_BUTTON) ...
// implemented as a c++ method
}

void MyClass::setup_glut(int argc, char** argv) { // largely boilerplate glut setup

glutInit(&argc, argv);

// ... the usual suspects go here like glutInitWindowSize(900, 800); ...

setupMouseButtonCallback(); // <-- custom linkage of c++ to cb

// ... other glut setup calls here
}

void MyClass::setupMouseButtonCallback() {

// c++ method which registers c function callback

::ptr_global_instance = this;
::glutMouseFunc(::mouse_buttons_callback);
}

在MyClass标题中，我们添加了：

1
2
3

void mouse_buttons_cb(int button, int state, int x, int y);

void setupMouseButtonCallback();

这也可以使用相同的逻辑流来设置您的供过于求。调用glutdisplayfunc(显示)

在这种情况下，不能使用非静态成员函数。基本上，glutmousefunc期望的参数类型是

1	void (*)(int, int, int, int)

而非静态成员函数的类型是

1	void (StartHand::*)(int, int, int, int)

第一个问题是类型不匹配。其次，为了能够调用该方法，回调必须知道您的方法属于哪个对象(即"this"指针)(这就是为什么类型在第一个地方是不同的)。第三，我认为您使用了错误的语法来检索方法的指针。正确的语法应该是：&；StartHand:：MouseButton。

因此，您必须将该方法设置为静态的，或者使用其他一些静态方法来知道要使用哪个starthand指针来调用mousebutton。