C++静态成员函数作为C回调需要访问非静态引用

Question

在我的C++代码中，我对C库有一个依赖关系。这个C库让我用3个参数定义一个回调函数。例如：

file.c：

#ifdef __cplusplus 
extern "C"{ 
#endif 
    typedef void(*callback)(argument* 1, argument* 2, argument* 3); 
... 
    void set_callback(ARG1, callback name_of_callback); 
... 

在C++库我开发我想此回调是一个类的成员函数，因为我不能直接传递一个成员函数作为回调C库我创建了一个静态函数作为回调函数，在这个静态函数中，我想引用一个类对象并调用它的成员函数来完成这个工作。

现在我的问题是，我的静态函数需要有C库指定的3个参数，所以我没有找到一种方法来引用我在该静态函数内开发的类的对象。我举例想做的事：

MyClass.h：

class MyClass: 
public: 
    MyClass(); 
    void my_function(argument*1, argument* 2, argument* 3); 
    static void my_callback(argument* 1, argument* 2, argument*3); 

MyClass.cpp：

MyClass::MyClass(){ 
    set_callback(ARG1, my_callback); 
} 

void MyClass::my_function(argument*1, argument* 2, argument* 3){ 
     /* Do something */} 
void MyClass::my_callback(argument* 1, argument* 2, argument*3){ 
    Object->my_function(1, 2, 3); 
} 

之所以不设置类成员为静态的是，我希望能够创建和销毁此类的对象用于测试目的并控制测试中对象的状态。

我正在使用g ++和gcc，希望有人可以提供一些帮助。 在此先感谢。

Answer 1

您可以创建一个静态成员函数或一个纯粹的 'C' 功能来做到这一点，可以考虑我下面的例子：

/** 
* C++ part 
*/ 
class obj 
{ 
public: 
    obj() {} 
    ~obj() {} 

    void doSomething(int a, int b) { cout << "result = " << a+b << endl; } 
}; 

/** 
* C Part 
*/ 
#ifdef __cplusplus 
extern "C" 
#endif 
{ 
typedef void (*callback)(void* one, void* two, void* three); 

callback g_ptr = NULL; 
void* arg = NULL; 

void c_lib_core (void) 
{ 
    printf ("C Lib core...\n"); 
    if (g_ptr) 
    { 
     g_ptr(arg, NULL, NULL); 
    } 
} 

void set_callback (void* arg, callback ptr) 
{ 
    g_ptr = ptr; 
} 

void my_callback (void* one, void* two, void* three) 
{ 
    obj* my_obj = (obj*) one; 

    my_obj->doSomething(1,2); 
} 

#ifdef __cplusplus 
} 
#endif 



int main (void) 
{ 
    obj a; 

    set_callback (&a, my_callback); 

    c_lib_core(); 
} 

输出：

C Lib core... 
result = 3 

我将一个指向C++对象的指针作为参数1传递给C++对象。这允许回调将它转换回C++并调用它。 c_lib_core的东西就是这样，我可以模拟回调函数的回调用于测试目的。这和全局变量一起在C代码中。你只需要实现一个C函数并将ARG1设置为你的对象，你就可以走了。

Answer 2

假设没有并发问题，我不知道是否是这种情况，更简单的解决方案可能是定义一个静态实例并在静态函数中使用它。

就是这样。

MyClass.h

class Object; 

class MyClass 
{ 
public: 
    MyClass(); 
    static Object* object; 
    static void callback(); 
    ~MyClass(); 

}; 

MyClass.cpp

Object* MyClass::object; 

MyClass::MyClass() 
{ 
    object = new Object(); 
} 

void MyClass::callback() { 
    object->sayHello(); 
} 

MyClass::~MyClass() 
{ 
    delete object; 
}