C++11 variadic std::function parameter

Question

A function named test takes std::function<> as its parameter.

template<typename R, typename ...A> void test(std::function<R(A...)> f) {     // ... } 

But, if I do the following:

void foo(int n) { /* ... */ }  // ...  test(foo); 

Compiler(gcc 4.6.1) says no matching function for call to test(void (&)(int)).

To make the last line test(foo) compiles and works properly, how can I modify the test() function? In test() function, I need f with type of std::function<>.

I mean, is there any template tricks to let compiler determine the signature of function(foo in example), and convert it to std::function<void(int)> automatically?

EDIT

I want to make this work for lambdas(both stated and stateless) as well.

Answer 1

It looks like you want to use overloading

template<typename R, typename ...A> void test(R f(A...)) {     test(std::function<R(A...)>(f)); } 

This simple implementation will accept most if not all the functions you will try to pass. Exotic functions will be rejected (like void(int...)). More work will give you more genericity.

Answer 2

std::function implements the Callable interface, i.e. it looks like a function, but that doesn't mean you should require callable objects to be std::functions.

template< typename F > // accept any type void test(F const &f) {     typedef std::result_of< F( args ) >::type R; // inspect with traits queries } 

Duck typing is the best policy in template metaprogramming. When accepting a template argument, be unspecific and just let the client implement the interface.

If you really need a std::function for example to re-target the variable or something crazy like that, and you know the input is a raw function pointer, you can decompose a raw function pointer type and reconsitute it into a std::function.

template< typename R, typename ... A > void test( R (*f)( A ... ) ) {     std::function< R( A ... ) > internal( f ); } 

Now the user can't pass a std::function because that has been encapsulated within the function. You could keep your existing code as another overload and just delegate to that, but be careful to keep interfaces simple.

As for stateful lambdas, I don't know how to handle that case. They don't decompose to function pointers and as far as I know the argument types cannot be queried or deduced. This information is necessary to instantiate std::function, for better or worse.