Is it possible to adapt C style api callback/handler to C++ for class related dynamic creation?

Question

Suppose we have some kind of C style API like this:

 void register_callback(target, callback_function);

, where target is some kind of object, e.g. a server, and call_back is required to be a function pointer.

Now we want to adapt (more precisely, add a wrapper layer. We have no access to the underlying C code, as it is a third-party library) this API to C++. We want OOP, so we make the target into a class:

class Target {
  Target(): target() { register_callback(target, callback_function_member) }
  private:
    target_t target;
    void callback_function_member (param_t parameter) { /* a set of things to do with the members */ }
    // other members
}

We probably want to make the callback a member function as above, because it (in some cases) is closely tied with the instance. But this won't work. There is no way to adapt member function into a function pointer (see, e.g. Pointers to Member Functions).

And all solutions I found on the internet (including the previous one) only deals with the case where only one instance is responsible for the job. There we can specially write a wrapper function (see 1) or static function of a wrapper class.

The problem is, what if we want multiple instances, and furthermore, dynamic creation of them? You can write a wrapper function or class for each instance, like

Target *pTarget;
void wrapper(param_t parameter) {
  pTarget->callback_function_member(parameter);
}
int main() {
  Target myTarget();
  pTarget = &myTarget();
  myTarget.register(wrapper);
  // some work
  return 0;
}

But you cannot write a function manually for each instance that is dynamically created. And it does not seem possible to pass any kind of information into the global function (e.g., store the instances in a global container, but how to pass the index when called?).

std::bind is close to the solution (whose existence is unknown to me), but the critical problem is that the return value of std::bind cannot be cast into a function pointer. Using target<type_of_function_pointer>() of std::function gets me a nil, as the type does not match. When I pretend it to be a function pointer and passed it directly, a segfault happens.

Is this possible after all? Or is my goal just misled? What is the canonical way of dealing with this problem?

Answer 1

If you really need a C-style callback, i.e. the one that calls the target callback through a regular function pointer, then the canonical way of dealing with this problem is to implement the actual callback as a "regular" (non-member or static member) function and pass the object pointer to it as an extra parameter

class SomeClass {
  ...
  void member_callback(int param1, double param2) { ... }
  static void static_callback_wrapper(int param1, double param2, void *user_param) {
    return static_cast<SomeClass *>(user_param)->member_callback(param1, params2);
  }
};

Now, if you have an object

SomeClass some_object;

and you want to use that callback with this object, in some external algorithm, you pass a pointer to SomeClass::static_callback_wrapper as the callback, and a pointer to some_object as "void * opaque user-specified data" to that algorithm. Of course, the algorithm has to be implemented with user-specified data in mind - it has to forward the void * pointer you passed from outside back to your callback.

For example, this is the convention pthread_create in pthreads library follows (http://man7.org/linux/man-pages/man3/pthread_create.3.html). The callback you pass to that function is void *(*start_routine) (void *), and the "user-specified data" is passed through the last void *arg parameter. The thread function will be invoked as start_routine(arg) thus forwarding that user-specified pointer back to the callback.

The same convention is used in non-standard qsort_r function (http://linux.die.net/man/3/qsort_r). Bascially, it is a good programming practice to include such "opaque user-specified data" forwarding mechanism into every implementation that employs C-style callbacks.

All this applies it you really need to conform to C-style callback interface. In pure C++ you have other, much more felxible, opportunities. You can represent the callback by a std::function object (as one possibility) and simply bind the implicit this argument of member functions to the object you want to use for the callback, thus turning them into "ordinary" functions.

void some_algorithm(std::function<void ()> callback) {
   ...
   callback();
   ...
   callback();
   ...
}

class SomeClass {
  void foo() {}
};

int main() {
  SomeClass object;
  some_algorithm(std::bind(&SomeClass::foo, &object));
}