overloaded templates resolution

Question

// g++(5.4)

void func(int * const &) {}
void func(int *) {}

template <typename T> void tfunc(const T &) {}
template <typename T> void tfunc(T *) {}

int main()
{
  int a = 0;

  func(&a);   // ambiguous
  tfunc(&a);  // unambiguous

  return 0;
}

According to my another test, tfunc(&a) instantiates the first template to void tfunc(int * const &) which has the same parameter type as the first nontemplate.

So, why is the first call ambiguous but the second not?

Answer 1

Given two function templates that are otherwise equally as good, overload resolution will select the more specialized function template, using a procedure commonly known as partial ordering. The exact rules are pretty complicated, but essentially it tries to determine if the set of arguments template A can be called with is a (proper) subset of the set of arguments template B can be called with. If so, then A is more specialized than B, and overload resolution will prefer A.

Thus, in your case, tfunc(const T&) can be called with ~everything; tfunc(T*) can only be called with pointers. The latter is more specialized, and is therefore selected.

If you are interested in the standardese and detailed rules, see [temp.func.order] and [temp.deduct.partial].