How do I Pass a Member Function to a Function as a Function Pointer?

Question

Source of Problem https://github.com/claydonkey/PointerToMember/tree/master

Although touched on in How Can I Pass a Member Function to a Function Pointer?, I feel somewhat dissatisfied with the solutions provided, as I don't want to introduce a dependency on the Boost library.

Comparing std::function for member functions is a post that gets close to a solution but ultimately is less optimistic about the use of std::function in . (it seems that member functions cannot be passed as function pointers)

The Problem:

A function simpleFunction which cannot be altered takes a callback pfunc:

typedef int (*FuncPtr_t)(void*, std::pair<int,int>&);
static int simpleFunction(FuncPtr_t pfunc, void *context, std::pair<int,int>& nos)
{
    pfunc(context, nos);
}

This function is intended to callback the method memberFunction in class SimpleClass:

NB removed void from original post as it better represents a real world usage.* was int memberFunction(void*, std::pair<int,int>& nos)

class SimpleClass {
public:  
    int memberFunction(std::pair<int,int>& nos) { return nos.first + nos.second; }
};

I expected the following to work:

MemFuncPtr_t MemFunction = &SimpleClass::memberFunction;
simpleFunction(obj.*MemFunction, nos);

but obj.*MemFunction has a type: int (SimpleClass::)(std::pair<int,int>&)

and it needs to be: int (*)(std::pair<int,int>&)

(wheras (obj.*MemFunction) (nos); returns as expected)

I can create and pass a trampoline:

int functionToMemberFunction(void* context, std::pair<int,int> & nos) {
     return static_cast<SimpleClass*>(context)->memberFunction(nos);
}

and pass it

simpleFunction(&functionToMemberFunction, &obj, nos);

but it compiles to around 40 instructions.

I can pass a lambda:

simpleFunction((FuncPtr_t)[](void* , std::pair<int,int> & nos) {
    return nos.first + nos.second;
}, &obj, nos);

That's surprisingly well optimised but a bit ugly and syntactically cumbersome. (NB Both and lambdas require C++11)

I can add a static member to SimpleClass:

class SimpleClass {
public:  
    int memberFunction(void*, std::pair<int,int>& nos) { return nos.first + nos.second; }
    static int staticFunction(void*, std::pair<int,int> & nos) { return nos.first + nos.second; }
};

FuncPtr_t StaticMemFunction = &SimpleClass::staticFunction;

and pass it

simpleFunction(StaticMemFunction, nullptr, nos);

and that's just, well ... a static function inside a class.

I can use the <functional> header:

using namespace std::placeholders;

std::function<int(std::pair<int,int>&) > f_simpleFunc = 
std::bind(&SimpleClass::memberFunction, obj, _1);

auto ptr_fun = f_simpleFunc.target<int (std::pair<int,int> & ) >();

and try and pass it...

simpleFunction(*ptr_fun, nos);

but ptr_fun reports null.

Looking at the x86 assembly - I am at a loss at how memory is addressed, calling a member function (there are an extra 5 instructions [3 mov, 1 lea and 1 add] over the StaticMemFunction call). I can only imagine that this is down to locating the class instance in memory and then the function within it.

A non-static member function needs access to `this`. You need some way to get that and a regular function pointer does not satisfy that. — NathanOliver, Aug 02 '16 at 15:03
but (obj.*pMemberFunction) (nullptr, nos); produces the correct result... Sorry for spamming language. The tags were suggested by stackoverflow itself + This is my first posting ever. — claydonkey, Aug 02 '16 at 15:08
Possible duplicate of [How do you pass a member function pointer?](http://stackoverflow.com/questions/130322/how-do-you-pass-a-member-function-pointer) — Garf365, Aug 02 '16 at 15:13
Because you passed `obj` as `pMemberFunction`'s `this` parameter in that call. — Miles Budnek, Aug 02 '16 at 15:13
As Jesper said the best option (for c++11) is to use `std::function` with `std::bind` — W.F., Aug 02 '16 at 15:25
tried: ```using namespace std::placeholders;``` ```std::function f_simpleFunc = std::bind(&SimpleClass::memFunction1, &obj, _1, _2);``` ```FuncPtr_t* ptr_fun = f_simpleFunc.target();``` ```simpleFunction(*ptr_fun, nullptr, nos);``` but ```ptr_fun``` returns ```null``` — claydonkey, Aug 02 '16 at 16:21
Jesper + W.F Please could you show me how to use std::Function in this example? — claydonkey, Aug 03 '16 at 08:58

claydonkey · Answer 1 · 2016-08-04T14:08:46.477

All the suggestions have been useful and I think if I collate them all and return to the original problem, I may have a solution that works for me.

So I thought a solution would be derived from:

simpleFunction(([](void* context,std::pair<int, int> & nos) {
   return nos.first + nos.second; 
}), &obj,  nos);

to become:

simpleFunction(([&](void* context,std::pair<int, int> & nos) {
   obj.memberFunction(nos);
}), &obj,  nos);

right?

error: cannot convert main()::<lambda(std::pair<int, int>&, void*)> to int (*)(std::pair<int, int>&, void*)

Lambdas that accept closures cannot be cast to a function pointer

The closure type for a lambda-expression with no lambda-capture has a public non-virtual non-explicit const conversion function to pointer to function having the same parameter and return types as the closure type’s function call operator. The value returned by this conversion function shall be the address of a function that, when invoked, has the same effect as invoking the closure type’s function call operator.

This makes sense as function pointers carry no state and this is why simpleFunction was gifted with a context pointer void* context (like most callbacks!), which is in turn handled by pFunc- the function pointer. (The context being the SimpleObject instance obj whose member function we wish to delegate to.)

Ergo a good solution seems to be:

solution 1

simpleFunction(([](void* context, std::pair<int,int>& n) {
    return static_cast<SimpleClass*>(context)->memberFunction(n);
}), &obj, nos);

NB If obj is moved from local -> global scope the lambda would not require the object to be passed in at all. but that changes the original problem.

Incredibly, if the member-function has no calls to the class within which it resides, it behaves as a static function, the lambda obviating the need for the class instance

solution 2

simpleFunction(([](void* context, std::pair<int,int>& n) {
    return static_cast<SimpleClass*>(context)->memberFunction(n);
}), nullptr /* << HERE */, nos); //WILL WORK even though the context is null!

This works perfectly as a solution to the original question: the member function indeed does not rely on anything outside the function scope (is this expected C++ behaviour or a happy hack?).

In conclusion, in trying to compose a simple analogy to a real world problem I have been naive in my the original question and I really want all the functionality of a member-function so solution 1 seems more realistic. I am little more savvy in distinguishing between member functions and c functions - I spose the clue was in the name member (of a class)

This was all part of a learning experience and the source code including move-semantics solutions is in the link in the original post.

score 1 · Answer 2 · answered Aug 03 '16 at 09:24

Implement a simple trampoline with a lambda:

#include <iostream>

typedef int (*FuncPtr_t)(void*, int);
static int simpleFunction(FuncPtr_t pfunc, void *context, int nos)
{
    return pfunc(context, nos);
}

struct A {
    int i;
    int pf(int nos) { std::cout << i << " nos = " << nos << "\n"; return i; }
};

int main() {
    A a { 1234 };
    // could combine the next two lines into one, I didn't.
    auto trampoline = [](void *inst, int nos) { return ((A*)inst)->pf(nos); };
    simpleFunction(trampoline, &a, 42);
}

http://ideone.com/74Xhes

I've modified it to consider the assembly:

typedef int (*FuncPtr_t)(void*, int);
static int simpleFunction(FuncPtr_t pfunc, void *context, int nos)
{
    return pfunc(context, nos);
}

struct A {
    int i;
    int pf(int nos) { return nos + i; }
};

int f(A& a) {
    auto trampoline = [](void *inst, int nos) { return ((A*)inst)->pf(nos); };
    return simpleFunction(trampoline, &a, 42);
}

Compiled with -O3 we get:

f(A&):
    movl    (%rdi), %eax
    addl    $42, %eax
    ret

https://godbolt.org/g/amDKu6

I.e. the compiler is able to eliminate the trampoline entirely.

Thanks kfsone but isn't that the same as case 3? : `simpleFunction((FuncPtr_t)[](void* , std::pair & nos) { return nos.first + nos.second; }, 0, nos);` _(The "Trampoline" being superflous)_ I think basically it boils down to **Lambda == Solution** — claydonkey, Aug 03 '16 at 10:14
Sorry I stand corrected as the question posited: the member function must be called inside the lambda. My bad... "A lambda can only be converted to a function pointer if it does not capture" http://stackoverflow.com/questions/28746744/passing-lambda-as-function-pointer — claydonkey, Aug 03 '16 at 11:55
kfsone Thanks again. So after a protracted process I finally concluded what you have already suggested. I would like to see the std::function in action at some point, also — claydonkey, Aug 04 '16 at 22:47

nate · Answer 3 · 2016-08-05T13:52:03.723

std::function<> plus lambdas are a nice way to go. Just capture the this in the lambda, an do what you need. You don't event need to write a separate callback if what is being executed is small. Plus std::function is required to not need a heap allocation for lambda that only captures a single pointer.

class A {
  std::function <void()> notify;
  void someProcessingFunction () {
    // do some work
    if (notify != nullptr)
      notify ();
  }
};

class B {
  void processNotification () {
    // do something in response to notification
  }
};

int main ()
{
  A a;
  B b;

  a.notify = [&b] () { b.processNotification (); };

  a.someProcessingFunction ();
}

nate: it would be great to see an example of std::function or/and std::bind in action. — claydonkey, Aug 05 '16 at 07:47

score 0 · Answer 4 · answered Aug 02 '16 at 17:39

0

The usual approach is to pass the object as your callback data, as you do in the first example. Any overhead is likely a consequence of the calling convention on your target (or perhaps too low a setting on your compiler's optimiser).

answered Aug 02 '16 at 17:39

Toby Speight

27,591
48
66
103

Thanks for the edits Toby. Are you sure the "trampoline" solution is modern c++? – claydonkey Aug 02 '16 at 21:44

score 0 · Answer 5 · answered Aug 03 '16 at 07:31

0

In these circumstances I use a fusion of your first two methods. That is, I create a trampoline, but make it a static function inside the class, to avoid clutter. It does not do what the member function does (as in your second example): it just calls the member function.

Don't worry about a handful of instructions in the calling process. If you ever do need to worry that much about clock cycles, use assembler.

answered Aug 03 '16 at 07:31

nugae

499
2
5

Surely even the lambda is preferable to the trampoline? (thanks to Toby Speight for the nomenclature "trampoline") – claydonkey Aug 03 '16 at 08:26
Yes, of course. The reason I don't use lambdas is that they don't exist in C++, only in C++11. If you can guarantee that every system you ever use your code on will have C++11 on it, then you can use lambdas. – nugae Aug 03 '16 at 16:21

How do I Pass a Member Function to a Function as a Function Pointer?

5 Answers5