How can I pass a member function where a free function is expected?

@Pete Becker's answer is fine but you can also do it without passing the class instance as an explicit parameter to function1 in C++ 11:

#include <functional> using namespace std::placeholders; void function1(std::function<void(int, int)> fun) { fun(1, 1); } int main (int argc, const char * argv[]) { ... aClass a; auto fp = std::bind(&aClass::test, a, _1, _2); function1(fp); return 0; } 

A pointer to member function is different from a pointer to function. In order to use a member function through a pointer you need a pointer to it (obviously ) and an object to apply it to. So the appropriate version of function1 would be

void function1(void (aClass::*function)(int, int), aClass& a) { (a.*function)(1, 1); } 

and to call it:

aClass a; // note: no parentheses; with parentheses it's a function declaration function1(&aClass::test, a); 

Since 2011, if you can change function1, do so, like this:

#include <functional> #include <cstdio> using namespace std; class aClass { public: void aTest(int a, int b) { printf("%d + %d = %d", a, b, a + b); } }; template <typename Callable> void function1(Callable f) { f(1, 1); } void test(int a,int b) { printf("%d - %d = %d", a , b , a - b); } int main() { aClass obj; // Free function function1(&test); // Bound member function using namespace std::placeholders; function1(std::bind(&aClass::aTest, obj, _1, _2)); // Lambda function1([&](int a, int b) { obj.aTest(a, b); }); } 

(live demo)

Notice also that I fixed your broken object definition (aClass a(); declares a function).

Important to note that unless you can change the signature of the code taking the function, there is no (easy) way to do this. That would be trying to implement a closure in a language that does not have closures that are the same as functions (the signature for a closure in C++ is different).

There are two actual ways to achieve this:

1. Use some sort of singleton/global variable that you store the closure in, and then pass a helper function that calls the needed function using that closure. Here is an example:

#include <stdio.h> template<class C, typename ReturnType, typename... Args> class ClosureSingleton { typedef ReturnType (C::*FuncType)(Args...); public: static ClosureSingleton& getInstance() { static ClosureSingleton instance; return instance; } void setClosure(C* obj, FuncType f) { this->obj = obj; this->function = f; } static ReturnType funcPtr(Args... args) { C* obj = getInstance().obj; auto func = getInstance().function; return (obj->*func)(args...); } private: ClosureSingleton() {} C* obj; FuncType function; public: ClosureSingleton(ClosureSingleton const&) = delete; void operator=(ClosureSingleton const&) = delete; }; class aClass { public: void aTest1(int a, int b) { printf("%d + %d = %d\n", a, b, a + b); } int aTest2(int a, int b) { return a + b; } }; void function1(void (*function)(int, int)) { function(1, 1); } int function2(int (*function)(int, int)) { return function(1, 1); } int main() { aClass tmp; ClosureSingleton<aClass, void, int, int>::getInstance().setClosure( &tmp, &aClass::aTest1); function1(&ClosureSingleton<aClass, void, int, int>::funcPtr); ClosureSingleton<aClass, int, int, int>::getInstance().setClosure( &tmp, &aClass::aTest2); printf( "function2: %d\n", function2(&ClosureSingleton<aClass, int, int, int>::funcPtr)); return 0; } 

Of course, this has the obvious downside that the closure needs to be set before every call, as well as some thread safety issues. Not ideal, but potentially workable in specific circumstances

2. Use something like asmjit or dynamic compilation to dynamically compile and pass the function in to the C code. This will only work on machines that allow heap section to be marked as executable. It is also very much non-portable as you will be writing assembly code to accomplish this. However, if you get it working, you will indeed have a true closure, albeit a substantially higher cost to creating the closure compared to how most programming languages implement closures (they do not duplicate the function assembly, instead they use a context object)
3. Patch the lib/dll that has the function handler to change it's signature to allow a context object. Again, a very brittle and non optimal solution.

My original answer, which does not really answer the question, but people found it useful:

Not sure why this incredibly simple solution has been passed up:

#include <stdio.h> class aClass { public: void aTest(int a, int b) { printf("%d + %d = %d\n", a, b, a + b); } }; template<class C> void function1(void (C::*function)(int, int), C& c) { (c.*function)(1, 1); } void function1(void (*function)(int, int)) { function(1, 1); } void test(int a,int b) { printf("%d - %d = %d\n", a , b , a - b); } int main (int argc, const char* argv[]) { aClass a; function1(&test); function1<aClass>(&aClass::aTest, a); return 0; } 

Output:

1 - 1 = 0 1 + 1 = 2 

I asked a similar question (C++ openframeworks passing void from other classes) but the answer I found was clearer so here the explanation for future records:

it’s easier to use std::function as in:

 void draw(int grid, std::function<void()> element) 

and then call as:

 grid.draw(12, std::bind(&BarrettaClass::draw, a, std::placeholders::_1)); 

or even easier:

 grid.draw(12, [&]{a.draw()}); 

where you create a lambda that calls the object capturing it by reference

I made the member function as static and all works:

#include <iostream> class aClass { public: static void aTest(int a, int b) { printf("%d + %d = %d\n", a, b, a + b); } }; void function1(int a,int b,void function(int, int)) { function(a, b); } void test(int a,int b) { printf("%d - %d = %d\n", a , b , a - b); } int main (int argc, const char* argv[]) { aClass a; function1(10,12,test); function1(10,12,a.aTest); // <-- How should I point to a's aClass::test function? getchar();return 0; } 

If you actually don't need to use the instance a (i.e. you can make it static like @mathengineer 's answer) you can simply pass in a non-capture lambda. (which decay to function pointer)

#include <iostream> class aClass { public: void aTest(int a, int b) { printf("%d + %d = %d", a, b, a + b); } }; void function1(void (*function)(int, int)) { function(1, 1); } int main() { //note: you don't need the `+` function1(+[](int a,int b){return aClass{}.aTest(a,b);}); } 

Wandbox

note: if aClass is costly to construct or has side effect, this may not be a good way.