How do I pass a pointer-to-member-function to a signal handler, X event callback, system call that starts a thread/task, etc?, C++ FAQ

C++ FAQ / Section 33 / FAQ 33.2

Section 33:

33.1	Is the type of "pointer-to-member-function" different from "pointer-to-function"?
33.2	How do I pass a pointer-to-member-function to a signal handler, X event callback, system call that starts a thread/task, etc?
33.3	Why do I keep getting compile errors (type mismatch) when I try to use a member function as an interrupt service routine?
33.4	Why am I having trouble taking the address of a C++ function?
33.5	How can I avoid syntax errors when creating pointers to members?
33.6	How can I avoid syntax errors when calling a member function using a pointer-to-member-function?
33.7	How do I create and use an array of pointer-to-member-function?
33.8	How do I declare a pointer-to-member-function that points to a `const` member function?
33.9	What is the difference between the `.` and `->` operators?
33.10	Can I convert a pointer-to-member-function to a `void*`?
33.11	Can I convert a pointer-to-function to a `void*`?
33.12	I need something like function-pointers, but with more flexibility and/or thread-safety; is there another way?
33.13	What the heck is a functionoid, and why would I use one?
33.14	Can you make functionoids faster than normal function calls?
33.15	What's the difference between a functionoid and a functor?

[33.2] How do I pass a pointer-to-member-function to a signal handler, X event callback, system call that starts a thread/task, etc?

Don't.

Because a member function is meaningless without an object to invoke it on, you can't do this directly (if The X Window System was rewritten in C++, it would probably pass references to objects around, not just pointers to functions; naturally the objects would embody the required function and probably a whole lot more).

As a patch for existing software, use a top-level (non-member) function as a wrapper which takes an object obtained through some other technique. Depending on the routine you're calling, this "other technique" might be trivial or might require a little work on your part. The system call that starts a thread, for example, might require you to pass a function pointer along with a void*, so you can pass the object pointer in the void*. Many real-time operating systems do something similar for the function that starts a new task. Worst case you could store the object pointer in a global variable; this might be required for Unix signal handlers (but globals are, in general, undesired). In any case, the top-level function would call the desired member function on the object.

Here's an example of the worst case (using a global). Suppose you want to call Fred::memberFn() on interrupt:

class Fred {
public:
  void memberFn();
  static void staticMemberFn();  // A static member function can usually handle it
  ...
};

// Wrapper function uses a global to remember the object:
Fred* object_which_will_handle_signal;

void Fred_memberFn_wrapper()
{
  object_which_will_handle_signal->memberFn();
}

int main()
{
  /* signal(SIGINT, Fred::memberFn); */   // Can NOT do this
  signal(SIGINT, Fred_memberFn_wrapper);  // OK
  signal(SIGINT, Fred::staticMemberFn);   // OK usually; see below
  ...
}

Note: static member functions do not require an actual object to be invoked, so pointers-to-static-member-functions are usually type-compatible with regular pointers-to-functions. However, although it probably works on most compilers, it actually would have to be an extern "C" non-member function to be correct, since "C linkage" doesn't only cover things like name mangling, but also calling conventions, which might be different between C and C++.