Forward member function to static method

Question

Context

Basically I need to have a const void *const for a member function, because that has to be passed to a third party library (which means I cannot use bind, function, etc). Since that seems to be impossible, I wanted to do the next best thing and map a member function to a static forwarding method, which I can then get the pointer for (passing this as first argument).

Question

I have a lot of functions that I need to register, with different signatures, so I would like to have a nice solution that allows me to convert a signature of a member function into a static method signature (passing this as an argument of course) - which I can then cast to a const void* const. So basically I want to do something like this:

So basically:

struct Foo
{ 
    MyType Bar(int a);
};

template <typename Ret, typename This, Ret(This::*Func)()>
struct CallWrap0
{
    static Ret &&Call(This* thisPtr)
    {
        return thisPtr->(*Func)();
    }
};

int Main()
{
    const void * const memberFunction = &(CallWrap0<MyType, Foo, Foo::Bar>()::Call);
    // etc.
}

The problem with this solution is that - even though it works - it's not very nice, because I have to explicitly tell the compiler the types. I'm looking for a solution where the compiler can fill in all the plumbing automagically.

I've been attempting to work around this with a helper function, so far without luck:

template <class Ret, class T, class... Args>
const void* const FunctionPtr(Ret (T::*function)(Args... args))
{
    // not sure... function is not a template, so this would require a class instance
    // which is not possible due to the ext. library constraints.
}

Piotr Skotnicki · Accepted Answer · 2015-09-15T07:55:59.947

4

#include <utility>

template <typename T, T t>
struct CallWrap;

template <typename Ret, typename This, typename... Args, Ret(This::*Func)(Args...)>
struct CallWrap<Ret(This::*)(Args...), Func>
{
    static Ret Call(This* thisPtr, Args... args)
    {
        return (thisPtr->*Func)(std::forward<Args>(args)...);
    }
};

int main()
{
    auto f = &CallWrap<decltype(&Foo::Bar), &Foo::Bar>::Call;
}

DEMO

For MSVC, which fails to compile the above solution, try the below code:

template <typename T>
struct CallWrap;

template <typename Ret, typename This, typename... Args>
struct CallWrap<Ret(This::*)(Args...)>
{
    template <Ret(This::*Func)(Args...)>
    struct Function
    {
        static Ret Call(This* thisPtr, Args... args)
        {
            return (thisPtr->*Func)(std::forward<Args>(args)...);
        }
    };
};

int main()
{
    auto f = &CallWrap<decltype(&Foo::Bar)>::Function<&Foo::Bar>::Call;
}

DEMO 2

edited Sep 15 '15 at 07:55

answered Sep 15 '15 at 07:35

Piotr Skotnicki

46,953
7
118
160

Nice, I wouldn't have thought of using `decltype`. I think that'll work. – atlaste Sep 15 '15 at 07:44
Awesome, just tested it, it works just fine. I'll happily accept this, thanks a lot! – atlaste Sep 15 '15 at 08:01
@atlaste is it a C++11 question then? – Wolf Sep 15 '15 at 08:02
1

@Wolf Yes, sorry, I should have been clear on that. I usually just hit build, to be honest I don't even think about it anymore. – atlaste Sep 15 '15 at 08:03
2

MSVC 2015 does compile the first demo, tested on http://webcompiler.cloudapp.net/ – TemplateRex Sep 15 '15 at 08:08
@TemplateRex yes, it was my bad... deleted my remark the moment I figured it out. I blame it on a lack of coffee. The solution provided by Piotr works just fine. – atlaste Sep 15 '15 at 17:43

Forward member function to static method

1 Answers1