10

I have discovered the following behaviour with std::function and type deduction, which was unexpected for me:

#include <functional>

template <typename T>
void stdfunc_test(std::function<T(T)> func) {};

int test_func(int arg)
{
    return arg + 2;
}

int main()
{
    stdfunc_test([](int _) {return _ + 2;});
    stdfunc_test(test_func);
}

Both lines in main result in error:

no instance of function template "stdfunc_test" matches the argument list

When attempting to compile in Visual Studio 2015.

Why doesn't the type deduction deduct template type from the function type, and is there a workaround for it?

skypjack
  • 49,335
  • 19
  • 95
  • 187
redspah
  • 257
  • 3
  • 9
  • 2
    Neither the lambda nor the function pointer is actually a `std::function` - they're implicitly convertible to a `std::function`. – aschepler Aug 26 '16 at 19:34
  • Are implicit conversions like that not taken into account when deducing template variables? – redspah Aug 26 '16 at 19:37
  • 2
    Just assume it is a function: `template void stdfunc_test(T func)`. Then limit the scope of the template with SFINAE. – rustyx Aug 26 '16 at 19:38
  • No, template parameter deduction does not consider user-defined conversions. And even if it did (though it doesn't) - `std::function` has a bunch of templated constructors that accept pretty much anything, give or take. – Igor Tandetnik Aug 27 '16 at 04:33

2 Answers2

5

You can use templates to deduce the signature of functions and functors:

#include<functional>

template<class T>
struct AsFunction
    : public AsFunction<decltype(&T::operator())>
{};

template<class ReturnType, class... Args>
struct AsFunction<ReturnType(Args...)> {
  using type = std::function<ReturnType(Args...)>;
};

template<class ReturnType, class... Args>
struct AsFunction<ReturnType(*)(Args...)> {
  using type = std::function<ReturnType(Args...)>;
};


template<class Class, class ReturnType, class... Args>
struct AsFunction<ReturnType(Class::*)(Args...) const> {
  using type = std::function<ReturnType(Args...)>;
};

template<class F>
auto toFunction( F f ) -> typename AsFunction<F>::type {
  return {f};
}

template <typename T>
void stdfunc_test(std::function<T(T)> func) {};

int test_func(int arg)
{
    return arg + 2;
}


int main()
{

    stdfunc_test( toFunction([](int _) {return _ + 2;}) );
    stdfunc_test( toFunction(test_func) );
    return 0;
}

you can try it live here: http://fiddle.jyt.io/github/d4ab355eb2ab7fc4cc0a48da261f0127

Gaetano
  • 1,090
  • 1
  • 9
  • 25
3

No implicit conversion is performed during template argument deduction, except: temp.deduct.call

In general, the deduction process attempts to find template argument values that will make the deduced A identical to A (after the type A is transformed as described above). However, there are three cases that allow a difference:

  • If the original P is a reference type, the deduced A (i.e., the type referred to by the reference) can be more cv-qualified than the transformed A.
  • The transformed A can be another pointer or pointer to member type that can be converted to the deduced A via a function pointer conversion ([conv.fctptr]) and/or qualification conversion ([conv.qual]).
  • If P is a class and P has the form simple-template-id, then the transformed A can be a derived class of the deduced A. Likewise, if P is a pointer to a class of the form simple-template-id, the transformed A can be a pointer to a derived class pointed to by the deduced A.

However, if the template parameter doesn't participate in template argument deduction, implicit conversion will be performed: (temp.arg.explicit)

Implicit conversions (Clause [conv]) will be performed on a function argument to convert it to the type of the corresponding function parameter if the parameter type contains no template-parameters that participate in template argument deduction. [ Note: Template parameters do not participate in template argument deduction if they are explicitly specified.

So, if you explicitly specify the template argument, it should work:

stdfunc_test<int>([](int _) {return _ + 2;});
stdfunc_test<int>(test_func);
Carousel
  • 728
  • 4
  • 13