使用 C++ 类成员函数作为 C 回调函数

Question

我有一个 C 库，需要注册一个回调函数来自定义一些处理。回调函数类型为int a(int *, int *)。

我正在编写类似于以下的 C++ 代码，并尝试注册一个 C++ 类函数作为回调函数：

class A {
  public:
   A();
   ~A();
   int e(int *k, int *j);
};

A::A()
{
   register_with_library(e)
}

int
A::e(int *k, int *e)
{
  return 0;
}

A::~A() 
{

}

编译器抛出以下错误：

In constructor 'A::A()',
error:
 argument of type ‘int (A::)(int*, int*)’ does not match ‘int (*)(int*, int*)’.

我的问题：

1. 首先，是否可以像我尝试的那样注册一个 C++ 类成员函数，如果可以，怎么做？ （我在http://www.parashift.com/c++-faq-lite/mixing-c-and-cpp.html 阅读了 32.8。但我认为它并不能解决问题）
2. 是否有替代/更好的方法来解决这个问题？

Answer 1

如果成员函数是静态的，则可以这样做。

A 类的非静态成员函数有一个class A* 类型的隐式第一个参数，它对应于this 指针。这就是为什么只有在回调的签名也有class A*类型的第一个参数时才能注册它们。

Answer 2

如果成员函数不是静态的，你也可以这样做，但它需要更多的工作（另见Convert C++ function pointer to c function pointer）：

#include <stdio.h>
#include <functional>

template <typename T>
struct Callback;

template <typename Ret, typename... Params>
struct Callback<Ret(Params...)> {
   template <typename... Args> 
   static Ret callback(Args... args) {                    
      return func(args...);  
   }
   static std::function<Ret(Params...)> func; 
};

template <typename Ret, typename... Params>
std::function<Ret(Params...)> Callback<Ret(Params...)>::func;

void register_with_library(int (*func)(int *k, int *e)) {
   int x = 0, y = 1;
   int o = func(&x, &y);
   printf("Value: %i\n", o);
}

class A {
   public:
      A();
      ~A();
      int e(int *k, int *j);
};

typedef int (*callback_t)(int*,int*);

A::A() {
   Callback<int(int*,int*)>::func = std::bind(&A::e, this, std::placeholders::_1, std::placeholders::_2);
   callback_t func = static_cast<callback_t>(Callback<int(int*,int*)>::callback);      
   register_with_library(func);      
}

int A::e(int *k, int *j) {
   return *k - *j;
}

A::~A() { }

int main() {
   A a;
}

这个例子在编译的意义上是完整的：

g++ test.cpp -std=c++11 -o test

您将需要c++11 标志。在代码中，您看到调用了register_with_library(func)，其中func 是动态绑定到成员函数e 的静态函数。

Answer 3

问题在于方法 != 函数。编译器会将你的方法转换成这样的：

int e( A *this, int *k, int *j );

所以，你肯定不能传递它，因为类实例不能作为参数传递。一种解决方法是将方法设为静态，这样它就会有好的类型。但它不会有任何类实例，并且可以访问非静态类成员。

另一种方法是声明一个带有静态指针的函数，该指针指向第一次初始化的 A。该函数仅将调用重定向到类：

int callback( int *j, int *k )
{
    static A  *obj = new A();
    a->(j, k);
}

然后就可以注册回调函数了。

Answer 4

嗯...如果您在 win32 平台上，总会有讨厌的 Thunking 方式...

Thunking in Win32: Simplifying callbacks to non-static member functions

这是一个解决方案，但我不建议使用它。
它有一个很好的解释，很高兴知道它的存在。

Answer 5

在这个解决方案中，我们有一个模板类 将静态方法作为回调提供给“c函数”。 此类拥有一个“普通”对象（带有一个名为 callback() 的成员函数，最终将被调用）。

一旦定义了您的类（此处为 A），就可以轻松使用它：

int main() {

  Holder<A> o ( A(23, 23) );

  std::cout << o().getN() << "\n";

  callACFunctionPtr( fun );

  callACFunctionPtr( o.callback );

} // ()

完整示例：

#include <iostream>

// ----------------------------------------------------------
// library class: Holder
// ----------------------------------------------------------
template< typename HeldObjectType >
class Holder {
public:
  static inline HeldObjectType object;

  static void callback( ) {
    object.callback();
  } // ()

  HeldObjectType &  operator() ( ) {
    return object;
  }

  Holder( HeldObjectType && obj )
  {
    object = obj;
  }

  Holder() = delete;

}; // class

// ----------------------------------------------------------
// "old" C function receivin a ptr to function as a callback
// ----------------------------------------------------------
using Callback = void (*) (void);

// ..........................................................
// ..........................................................
void callACFunctionPtr( Callback f ) {
  f();
} // ()

// ----------------------------------------------------------
// ----------------------------------------------------------
void fun() {
  std::cout << "I'm fun\n";
} // 

// ----------------------------------------------------------
// 
// Common class where we want to write the
// callback to be called from callACFunctionPtr.
// Name this function: callback
// 
// ----------------------------------------------------------
class A {
private:
  int n;

public:

  A(  ) : n( 0 ) { }

  A( int a, int b ) : n( a+b ) { }

  void callback( ) {
    std::cout << "A's callback(): " << n << "\n";
  }

  int getN() {
    return n;
  }

}; // class

// ----------------------------------------------------------
// ----------------------------------------------------------
int main() {

  Holder<A> o ( A(23, 23) );

  std::cout << o().getN() << "\n";

  callACFunctionPtr( fun );

  callACFunctionPtr( o.callback );

} // ()

Answer 6

使用成员函数的问题是它需要一个对象来执行 - 而 C 不知道对象。

最简单的方法是执行以下操作：

//In a header file:
extern "C" int e(int * k, int * e);

//In your implementation: 
int e(int * k, int * e) { return 0; }