Reputation: 60381
Consider the following function in C++11:
template<class Function, class... Args, typename ReturnType = /*SOMETHING*/>
inline ReturnType apply(Function&& f, const Args&... args);
I want ReturnType
to be equal to the result type of f(args...)
What do I have to write instead of /*SOMETHING*/
?
Upvotes: 4
Views: 2864
Reputation: 361422
I think you should rewrite your function template using trailing-return-type as:
template<class Function, class... Args>
inline auto apply(Function&& f, const Args&... args) -> decltype(f(args...))
{
typedef decltype(f(args...)) ReturnType;
//your code; you can use the above typedef.
}
Note that if you pass args
as Args&&...
instead of const Args&...
, then it is better to use std::forward
in f
as:
decltype(f(std::forward<Args>(args)...))
When you use const Args&...
, then std::forward
doesn't make much sense (at least to me).
It is better to pass args
as Args&&...
called universal-reference and use std::forward
with it.
Upvotes: 15
Reputation: 171
There are situations where std::result_of is more useful. For example, say you want to pass this function:
int ff(int& out, int in);
and inside apply() call it like so
int res;
f(res, args...);
then I wouldn't know how to use decltype, because I have no int lvalue reference at hand. With result_of, you don't need variables:
template<class Function, class... Args>
typename std::result_of<Function(const Args&...)>::type apply(Function&& f, const Args&... args)
{
typedef typename std::result_of<F(const Args&...)>::type ReturnType;
// your code
}
Upvotes: 0
Reputation: 283634
It doesn't need to be a template parameter, since it isn't used for overload resolution. Try
template<class Function, class... Args>
inline auto apply(Function&& f, const Args&... args) -> decltype(f(std::forward<const Args &>(args)...));
Upvotes: 4