How to determine which template will be used

Question

I'm learning about templates in c++ and I found the following example.

From what I understand, the compiler should always try to use the most "specialized" template if there is no non-template functions matching, yet in this example, the first call result in calling function a(T*) instead of a(int*). Why? And why does second call act differently?

template<typename T>
void a(T) {cout << "(T)" << endl;}

template<>
void a<>(int*) {cout << "(int)" << endl;}

template<typename T>
void a(T*) {cout << "(T*)" << endl;}

template<typename T>
void b(T) {cout << "(T)" << endl;}

template<typename T>
void b(T*) {cout << "(T*)" << endl;}

template<>
void b<>(int*) {cout << "(int)" << endl;}

int main()
{
  int i;
  a(&i);
  b(&i); 
  return 0;
}

The resulting output is:

(T*)
(int)

I expected it to be:

(int)
(int)

Answer 1

Only primary templates (so no specializations) are taken into account to select more specialized overloads.

Once selection is done with primary template, we use the specialization if any.

Now, template<> void a<>(int*); can only be specialization of template<typename T> void a(T) (the other version has not been seen).

and template<> void b<>(int*); is specialization of template<typename T> void b(T*) (it is the more specialized matching overloads).

Notice that you might select specialization of b by providing template instead of letting compiler deduce:

• template<> void b<>(int*) -> template<typename T> void b(T*) with T=int
• template<> void b<int>(int*) -> template<typename T> void b(T*) with T=int
• template<> void b<int*>(int*) -> template<typename T> void b(T) with T=int*

so for:

int i;
a(&i); // a<T*> with T=int*, no specialization for a<U*> (U=int) exist -> generic template called
b(&i); // b<T*> with T=int*, specialization for b<U*> (U=int) exists -> specialization called