c++ class template can be instantiated but a function template instantiation with the same template parameters fails

Question

I have a wrapper class for binded function calls (a helper class to fight some legacy code issues):

template <class Result, class... Args>
class FunctionWrapper
{
    std::function<Result()> func_;
public:
    FunctionWrapper(std::function<Result(Args...)> f, Args&&... args) :
        func_(std::bind(f, std::forward<Args>(args)...))
    {
    }
    //...some methods using that func_
};

I can write the following code, which compiles and works just fine:

double f(int i, double d)
{
    return i*d;
}
//...
FunctionWrapper<double, int, double> w(f, 2, 4.5);
//calling methods of w ...

Now I want to save me some typing when defining a wrapper instance, so I've introduced the make_wrapper function:

template <class Result, class... Args>
FunctionWrapper<Result, Args...> make_wrapper(std::function<Result(Args...)> f, Args&&... args)
{
    return FunctionWrapper<Result, Args...>(f, std::forward<Args>(args)...);
}

Although the template parameter list for this function is identical to the one of the the wrapper class this can not be compiled (adding template parameters to "help" a compiler doesn't help either):

auto w1=make_wrapper(f, 2, 4.5); //error: no matching function for call to 'make_wrapper', candidate template ignored: could not match 'function<type-parameter-0-0 (type-parameter-0-1...)>' against 'double (*)(int, double)'

auto w2=make_wrapper<double, int, double>(f, 2, 4.5); //error: no matching function for call to 'make_wrapper', candidate template ignored: could not match 'function<double (int, double, type-parameter-0-1...)>' against 'double (*)(int, double)'

The compiler is LLVM 6.1 (the current XCode one). So, what is going on here? Is it possible to fix the make function?

Answer 1

The problem is that your first argument to make_wrapper() doesn't have the type you claim it has. Although a function pointer is convertible to a corresponding std::function<...> the compiler won't use the std::function<...> to deduce template arguments. Even if you'd make it a nested type to haveArgs...be deduce by the other argument, theResult` type cannot be deduced by the conversion.

If you really just want to bind function pointers, it should work to expect at function pointer as argument:

template <class Result, class... Args>
FunctionWrapper<Result, Args...>
make_wrapper(Result (*f)(Args...), Args&&... args)
{
    return FunctionWrapper<Result, Args...>(f, std::forward<Args>(args)...);
}

When the arguments of the function pointer and the arguments passed actually disagree, it may be necessary to have separate template argument lists for the function arguments and the parameters to be bound:

template <class Result, class... FArgs, class... Args>
FunctionWrapper<Result, FArgs...>
make_wrapper(Result (*f)(FArgs...), Args&&... args)
{
    return FunctionWrapper<Result, FArgs...>(f, std::forward<Args>(args)...);
}

I would probably go with an alternative which doesn't really care about the actual type of the function object argument and just deduces whatever function type that is produced:

template <class Fun, class... Args>
auto make_wrapper(Fun fun, Args&&... args)
    -> FunctionWrapper<decltype(fun(std::forward<Args>(args)...)), Args...>
{
    return FunctionWrapper<decltype(fun(std::forward<Args>(args)...)), Args...>(f, std::forward<Args>(args)...);
}

Answer 2

The problem is that the compiler can't match the type of the argument, which is double(int, double) here to std::function<double(int,double)>, there's no automatic conversion here!

You need to take a function pointer, not a std::function as a parameter:

template <class Result, class... Args>
FunctionWrapper<Result, Args...> make_wrapper(Result(*f)(Args...), Args&&... args)
{
    return FunctionWrapper<Result, Args...>(f, std::forward<Args>(args)...);
}