Could you explain why the following code doesn't compile? An obvious workaround is to add a 1-argument overload of Apply, is there a simpler one?
template <typename T>
T Identity(const T& i_val)
{
return i_val;
}
template <typename Val, typename Fn>
Val Apply(const Val& v, Fn fn = Identity<Val>)
{
return fn(v);
}
int main() {
Apply(42); // error: no matching function for call to 'Apply(int)'
Apply(42, Identity<int>); // OK
return 0;
}
Template argument deduction doesn't work that way -- you can't deduce the type of an argument from a defaulted value. In C++11, you can however specify a default template argument:
template <typename Val, typename Fn = Val(&)(Val const &)>
Val Apply(const Val& v, Fn fn = Identity<Val>)
{
return fn(v);
}
you can't deduce the type of an argument from a defaulted value with example in your answer? thanks
fn from a value that's given as a defaulted function argument. Argument deduction can only be performed on function arguments that were specified at the call site.Looking up the function to call consists of: 1. creating the set of candidates, which includes template argument deduction 2. determining the best overload
If I understand the standard correctly, only actual function arguments (i.e., not the default ones) take part in deducing the template arguments. Therefore from the argument 42, the only thing the compiler can infer is that Val = int. The overload does not enter the candidate set and the default argument is never looked at.
Apply is a templated function. You need to do Apply<MyValueType,MyFuncType>(42);
You could reasonably expect the compiler to infer Val to be int, but you can't expect it to infer the type of function, even though you've given a default parameter. As a result, it won't infer that you're trying to call that declaration of the Apply function.
Identityfunction always makes a copy -- is that intentional?