模板函数中的std :: function

Question

I was trying to write a template function which can accept functor as parameter and call it afterwards. The program is as follows:

#include <iostream>
#include <functional>
using namespace std;

template<typename R, typename... Args>
R call(function<R(Args...)> fun, Args... args)
{
    cout << "call@ " << __LINE__ <<endl;
    return fun(args...);
}

int main()
{
    cout << call(std::plus<int>(),1,2) <<endl;
    return 0;
}

The G++ compplains:

g++ -c -Wall -std=c++0x -I../include a.cpp -o a.o
a.cpp: In function ‘int main()’:
a.cpp:16:38: error: no matching function for call to ‘call(std::plus<int>, int, int)’
a.cpp:16:38: note: candidate is:
a.cpp:7:3: note: template<class R, class ... Args> R call(std::function<_Res(_ArgTypes ...)>, Args ...)
a.cpp:7:3: note:   template argument deduction/substitution failed:
a.cpp:16:38: note:   ‘std::plus<int>’ is not derived from ‘std::function<_Res(_ArgTypes ...)>’
make: *** [a.o] Error 1

I suppose std::plus<int>() could be deduced to std::function<int(int,int)> , but it didn't. Why was that? GCC is gcc version 4.7.2 20120921 (Red Hat 4.7.2-2) (GCC)

Answer 1

I suppose std::plus() could be deduced to std::function

No. It could not be deduced given that you have passed an object of type std::plus<int> .

In your case, you do not need to use std::function , as generally you would mostly use it when storing different functions/function objects that can be called with a specific signature.

With that, you can just have your call function accept the function/function object directly, with its original type deduced, without using std::function . Also, you might also want to use perfect forwarding when accepting the parameters and use std::forward when passing them as arguments to the function/function object. You should also use the return type of your function as the return type of call . Use C++11's trailing return type with decltype for that.

#include <iostream>
#include <functional>
using namespace std;

template<typename R, typename... Args>
auto call(R fun, Args&&... args) -> decltype(fun(std::forward<Args>(args)...))
{
    cout << "call@ " << __LINE__ <<endl;
    return fun(std::forward<Args>(args)...);
}

int main()
{
    cout << call(std::plus<int>(),1,2) <<endl;
    return 0;
}

LIVE CODE

---

As what @Jan Hudec has commented , __LINE__ in there will always result the same in all calls to call , whatever function is passed.

Answer 2

It can't deduce the template arguments.

I would recommend changing the function signature like so:

template<typename F, typename... Args>
auto call(F fun, Args... args )
    -> decltype( fun(args...) )

Answer 3

Most implicit conversions are not considered when deducing template arguments. Certainly not user-defined ones. So even if plus is convertible to function , it doesn't make a difference.