Cannot Convert From type x to type x

Question

I got a simple class which just wraps a function call to a classes method. When compiling (Using Visual Studio 2013) I get the error message:

Error 2 error C2664: 'Sleipnir::Core::Delegate::Delegate(const Sleipnir::Core::Delegate &)' : cannot convert argument 2 from 'void (__cdecl *)(void *const ,int &&)' to 'void (__cdecl *)(void *const ,int &&)' d:\programmieren\delegate\delegate\delegate.h 29 1 Delegate

which is not really helpful.

My code:

    template<typename T>
    class Delegate;

    template<typename R, typename... A>
    class Delegate<R(A...)>
    {
        using TFunc = R(*)(void* const, A&&...);

    private:
        Delegate(void* const obj, TFunc stub)
            : _objectPtr(obj),
            _stubPtr(stub){}
    public:
        Delegate(R(*const funcPtr)(A...))
            : Delegate(nullptr, functionStub<R(*)(A...)>)
        {

        }
    private:
        template <R(*funcPtr)(A...)>
        static R functionStub(void* const, A&&... args)
        {
            return funcPtr(::std::forward<A>(args)...);
        }
    private:
        void*   _objectPtr;
        TFunc   _stubPtr;
    };

anyone got an idea why this happens, or how to fix it?

Answer 1

The first problem I found was that you were referencing functionStub as functionStub<R(*)(A...)> which was wrong because functionStub takes a function pointer, not a type. The logical fix would be to pass in the address of funcPtr as functionStub<funcPtr>, but that fails as well. I believe this is because function arguments are not constant expressions so passing in the address of funcPtr is ill-formed because templates can only instantiate with constant expressions and types.

So I suggested in the comments that you should pass funcPtr to the parameter of functionStub by changing its signature to the following:

static R functionStub(R (*funcPtr)(A...), void* const, A... args);

The subsequent problem with this is that the function type differs from TFunc. You can solve this by std::bind()'ing functionStub to funcPtr first:

: Delegate(nullptr, std::bind(&functionStub, funcPtr, placeholders::_1))

This also requires changing TFunc to a std::function:

using TFunc = std::function<R (void* const, A...)>;

Now we have gotten rid of the errors, but the bind only placeholds one parameter for the call. A... could be any number of parameters so we have to use some mechanism that placeholds for a variadic number of arguments.

You can use the easy_bind() method as shown in this thread.

: Delegate(nullptr, easy_bind(&functionStub, funcPtr))

And lastly, &functionStub can't be deduced as a std::function type by easy_bind()'s arguments, so you can use a make_function() for that.

template <class Callable>
std::function<Callable> make_function(Callable* callable)
{
    return { callable };
}

// ...
: Delegate(nullptr, easy_bind(make_function(&functionStub), funcPtr))

Demo

Answer 2

It's failing because of this line:

using TFunc = R(*)(void* const, A&&...);

The delegate's public constructor is deferring to the private constructor, which is expecting a pointer to a function that takes a void* followed by an int. You are passing a function that takes only an int.

I suspect you're looking to build a delegate that can handle both free functions and functions that take a context parameter (such as a this pointer).

std::function takes care of all of that stuff for you. Are you able to write your delegate in terms of std::function<R(A&&...)> ? If so, you can use std::bind to store the object pointer for a member function callback.

Answer 3

Got it to work now, thank to 0x499602D2

Here's the code to my Delegate class:

    template <class Callable>
    std::function<Callable> make_function(Callable* callable)
    {
        return{ callable };
    }

    template<typename T>
    class Delegate;

    template<typename R, typename... A>
    class Delegate<R(A...)>
    {
        using TFunc = std::function<R(void* const, A...)>;
    private:
        Delegate(void* obj, TFunc stub)
            : _objectPtr(obj),
            _stubPtr(stub)
        {}
    public:
        Delegate(R(*funcPtr)(A...))
            : Delegate(nullptr, easy_bind(make_function(&functionStub), funcPtr))
        { }

        template <class C>
        Delegate(C* const objectPtr, R(C:: * const methodPtr)(A...))
            : Delegate(objectPtr, easy_bind(make_function(&methodStub<C>), methodPtr))
        { }

        template <class C>
        Delegate(C* const objectPtr, R(C:: * const methodPtr)(A...) const)
            : Delegate(objectPtr, easy_bind(make_function(&constMethodStub<C>), methodPtr))
        { }
    public:
        R operator()(A... args) const
        {
            return _stubPtr(_objectPtr, ::std::forward<A>(args)...);
        }
    private:
        static R functionStub(R(*funcPtr)(A...), void* const, A... args)
        {
            return funcPtr(std::forward<A>(args)...);
        }
        template <class C>
        static R methodStub(R(C::* const methodPtr)(A...), void* const objectPtr, A... args)
        {
            return (static_cast<C*>(objectPtr)->*methodPtr)(std::forward<A>(args)...);
        }
        template <class C>
        static R constMethodStub(R(C::* const methodPtr)(A...) const, void* const objectPtr, A... args)
        {
            return (static_cast<C*>(objectPtr)->*methodPtr)(std::forward<A>(args)...);
        }
    private:
        void*   _objectPtr;
        TFunc   _stubPtr;

And how i use it in my main class:

    void test(int x)
{
    std::cout << "Test - print: " << x << std::endl;
}

struct Printer
{
    void print(int x){
        std::cout << "Printer - print: " << x << std::endl;
    }

    void print2(int x) const{
        std::cout << "Printer - print2: " << x << std::endl;
    }
};

int main(int argc, void* args)
{

    Printer printer;

    Delegate<void(int)> del(&test);
    Delegate<void(int)> del2(&printer, &Printer::print);
    Delegate<void(int)> del3(&printer, &Printer::print2);
    del(1);
    del2(1);
    del3(1);
}