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?

score 22 · Accepted Answer · edited Jun 20 '20 at 09:12

22

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.

edited Jun 20 '20 at 09:12

Community

1
1

answered Mar 09 '12 at 04:36

James McNellis

348,265
75
913
977

20

While saying "Because the standard says so" is a valid answer, it would be nice to know the reasoning behind it. – Jesse Good Mar 09 '12 at 04:39
2

Among other reasons, different declarations of a function can declare different default arguments (I'm fairly certain the same applies to function templates.) – James McNellis Mar 09 '12 at 04:42
2

@James: No, different declarations are not allowed to declare different default arguments. It's not even allowed for multiple declarations to give the same default to the same argument. 8.3.6 says "A default argument shall not be redeﬁned by a later declaration (not even to the same value)." Of course, that only applies to non-template functions. For template functions, it looks like default arguments can only be provided on the initial declaration. – Ben Voigt Sep 03 '13 at 05:03
4

Another workaround besides a default template argument is to have a second function that calls the first with the appropriate default `inline void bar(int a){ bar(a, 0.0f);}` – Eponymous Nov 08 '17 at 21:05

score 18 · Answer 2 · answered Sep 04 '15 at 17:27

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:

attempt to deduce template parameters for candidates (A) and (B); this fails for (A), which is therefore eliminated.
perform overload resolution; (B) is selected
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.

So the compiler can just make that case non-viable. Don't have to throw the baby out with the bath water. — Adrian, Dec 03 '21 at 10:23

score 4 · Answer 3 · answered Mar 09 '12 at 04:55

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.

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

3 Answers3

Linked

Related