template<class T, class U> void f(T,U) { cout <<__PRETTY_FUNCTION__<<endl; }
template<class T> void f(T,T)          { cout <<__PRETTY_FUNCTION__<<endl; }
template<class T> void f(T,char)       { cout <<__PRETTY_FUNCTION__<<endl; }
//void f(char,char)                    { cout <<__PRETTY_FUNCTION__<<endl; }

int main()
{
int x=0; char c=0;
f(x,c); // T,char T=int
f(x,x); // T,T    T=int
f(c,x); // T,U    T=char,U=int
f(c,c); // неоднозначность между T,T и T,char, лечится раскомментированием f(char,char)
...

...
f<char,char>(x,x); // T,U    T=char,U=char
f<int>(x,c);       // T,char T=int
f<int>(c,x);       // T,T    T=int
f<int>(c,c);       // T,char T=int - вот здесь я затрудняюсь объяснить, почему так.
}

#include <stdio.h>

template<class T>
void g(T,T)
{
  static int a[sizeof(T)-sizeof(T) ? 1 : -1];
  printf("1\n");
}

template<class T>
void g(T,char)
{
  static int a[sizeof(T)-sizeof(T) ? 1 : -1];
  printf("2\n");
}

int main()
{
  g('a','1'); //1 error, not 3.
}

#include <stdio.h>

template<class T> struct X {};

template<class T>
void g(X<T>,char)
{
  printf("1\n");
}

template<class T>
void g(T,char)
{
  printf("2\n");
}

int main()
{
  g(X<char>(),'1'); //Ok
}

V>А в этом случае выборка делается вообще из 2х функций, а не из трёх.

V>template<class T>
V>void g(X<T>,char);

V>template<class T>
V>void g(T,char);

V>  g(X<char>(),'1'); //Ok
V>

void boo( void(*f)(char,char) );
....
boo(g);

V>>А в этом случае выборка делается вообще из 2х функций, а не из трёх.

"ComeauTest.c", line 23: error: more than one instance of overloaded function "g"
          matches the argument list, the choices that match are:
            function template "void g(T, T)"
            function template "void g(T, char)"
            The argument types that you used are: (char, char)
    g('a','1');
    ^

1 error detected in the compilation of "ComeauTest.c".

V>>template<class T>
V>>void g(X<T>,char);

V>>template<class T>
V>>void g(T,char);

V>>  g(X<char>(),'1'); //Ok
V>>

V>>"ComeauTest.c", line 23: error: more than one instance of overloaded function "g"
V>>          matches the argument list, the choices that match are:
V>>            function template "void g(T, T)"
V>>            function template "void g(T, char)"
V>>            The argument types that you used are: (char, char)
V>>    g('a','1');
V>>    ^
V>>1 error detected in the compilation of "ComeauTest.c".
V>>

Специализации шаблонов функций участвуют в процессе разрешениия перегрузки наравне с non-template функциями.

template<class T> void g(T) { cout << "general" << __PRETTY_FUNCTION__ << endl; }
template<> void g<int>(int) { cout << "special" << __PRETTY_FUNCTION__ << endl; }

V>Т.е. вы подтвердили что оно участвует не наравне.

14.7.1/8
If a function template or a member function template specialization is used in a way that involves overload resolution, a declaration of the specialization is implicitly instantiated

14.8.3/6
Only the signature of a function template specialization is needed to enter the specialization in a set of candidate functions. Therefore only the function template declaration is needed to resolve a call for which a template specialization is a candidate.

13.3.1/7
In each case where a candidate is a function template, candidate function template specializations are generated using template argument deduction (14.8.3, 14.8.2). Those candidates are then handled as candidate functions in the usual way. A given name can refer to one or more function templates and also to a set of overloaded non-template functions. In such a case, the candidate functions generated from each function template are combined with the set of non-template candidate functions.

13.3.3/1
...
a viable function F1 is defined to be a better function than another viable function F2 if for all arguments i, ICSi(F1) is not a worse conversion sequence than ICSi(F2), and then
— for some argument j, ICSj(F1) is a better conversion sequence than ICSj(F2), or, if not that,
— F1 is a non-template function and F2 is a function template specialization, ...

14.8.3/2
...
The function template specializations are treated like any other functions in the remainder of overload resolution, except as explicitly noted in 13.3.3.

...Therefore the function template specializations can be treated as normal (non-template) functions for the remainder of overload resolution.