Использование функции-члена класса C++ в качестве функции обратного вызова C

Вы можете сделать это, если функция-член является статической.

Нестатические функции-члены класса A имеют неявный первый параметр типа class A*, который соответствует указателю this. Вот почему вы могли бы зарегистрировать их только в том случае, если бы сигнатура обратного вызова также имела первый параметр типа class A*.

Вы также можете сделать это, если функция-член не является статической, но для этого требуется немного больше работы (см. также Преобразовать указатель функции C++ в указатель функции c):

#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.

Проблема в том, что метод != функция. Компилятор преобразует ваш метод во что-то вроде этого:

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

Итак, вы точно не сможете его передать, потому что экземпляр класса нельзя передать в качестве аргумента. Один из способов обойти это сделать метод статическим, таким образом, он будет иметь правильный тип. Но это будет не экземпляр класса, а доступ к нестатическим членам класса.

Другой способ — объявить функцию со статическим указателем на A, инициализированным в первый раз. Функция только перенаправляет вызов в класс:

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

Затем вы можете зарегистрировать функцию обратного вызова.

Ну... если вы работаете на платформе win32, всегда есть неприятный способ Thunking...

Thunking в Win32: упрощение обратных вызовов для нестатических функций-членов

Это решение, но я не рекомендую его использовать.
У него есть хорошее объяснение, и приятно знать, что оно существует.

Проблема с использованием функции-члена заключается в том, что ей нужен объект для действия, а C ничего не знает об объектах.

Проще всего было бы сделать следующее:

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

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

В этом решении у нас есть класс шаблона со статическим методом, который будет передан «функции 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 );

} // ()