Why can't the compiler deduce the template type from default arguments?

Question

I was surprised the following code resulted in a could not deduce template argument for T error:

struct foo
{
  template <typename T>
  void bar(int a, T b = 0.0f)
  {
  }
};

int main()
{
  foo a;
  a.bar(5);

  return 0;
}

Calling a.bar<float>(5) fixes the issue. Why can't the compiler deduce the type from the default argument?

Answer 1

In C++03, the specification explicitly prohibits the default argument from being used to deduce a template argument (C++03 §14.8.2/17):

A template type-parameter cannot be deduced from the type of a function default argument.

In C++11, you can provide a default template argument for the function template:

template <typename T = float>
void bar(int a, T b = 0.0f) { }

The default template argument is required, though. If the default template argument is not provided, the default function argument is still not usable for template argument deduction. Specifically, the following applies (C++11 14.8.2.5/5):

The non-deduced contexts are:

...

• A template parameter used in the parameter type of a function parameter that has a default argument that is being used in the call for which argument deduction is being done.

Answer 2

There would be some technical difficulties in achieving that in general. Remember that default arguments in templates are not instantiated until they are needed. Consider then:

template<typename T, typename U> void f(U p = T::g());  // (A)
template<typename T> T f(long, int = T());  // (B)
int r = f<int>(1);

This is resolved today by performing (among other things) the following steps:

1. attempt to deduce template parameters for candidates (A) and (B); this fails for (A), which is therefore eliminated.
2. perform overload resolution; (B) is selected
3. form the call, instantiating the default argument

In order to deduce from a default argument, that default argument would have to be itself instantiated before completing the deduction process. That could fail, leading to errors outside the SFINAE context. I.e., a candidate that may be entirely inappropriate for a call could trigger an error.

Answer 3

A good reason might be that

void foo(bar, xyzzy = 0);

is similar to a pair of overloads.

void foo(bar b) { foo(b, 0);  }
foo(bar, xyzzy);

Moreover, sometimes it is advantageous to refactor it into such:

void foo(bar b) { /* something other than foo(b, 0); */ }
foo(bar, xyzzy);

Even when written as one, it's still like two functions in one, neither of which is "preferred" in any sense. You're calling the one-argument function; the two-argument one is effectively a different function. The default argument notation just merges them into one.

If overloading were to have the behavior that you are asking for, then for consistency it would have to work in the case when the template is split up into two definitions. That wouldn't make sense because then the deduction would be pulling types from an unrelated function that is not being called! And if it was not implemented, it would mean that overloading different parameter list lengths becomes a "second class citizen" compared to "default-argumenting".

It is good if the difference between overloads and defaulting is completely hidden to the client.