template<class T>
void fun(T);
template<class T>
void fun(T *);

template<>
void fun(int *)
{
}

 > template<class T>
 > void fun(T);
 > template<class T>
 > void fun(T *);

 > // template<> 
 > void fun(int *)
 > {
 > }
 >

int main()
{
    int i = 0;
    char c = 0;
  
    fun(i);       // fun(T)
    fun(&i);    // fun(int*)
    fun(c);     // fun(T)
    fun(&c);   // fun(T*)

    fun( (int*)&c );   // нагло врём о типе параметра - получаем вызов fun(int*)
}

 > template<class T>
 > void fun(T);

 > template<class T>
 > void fun(T *);

 > template<>
 > void fun(int *)
 > {
 > }
 >

2 Given two overloaded function templates, whether one is more specialized than another can be determined by transforming each template in turn and using argument deduction (14.8.2) to compare it to the other.
3 The transformation used is:
— For each type template parameter, synthesize a unique type and substitute that for each occurrence of that parameter in the function parameter list, or for a template conversion function, in the return type.
— For each nontype template parameter, synthesize a unique value of the appropriate type and substitute that for each occurrence of that parameter in the function parameter list, or for a template conversion function, in the return type.
— For each template template parameter, synthesize a unique class template and substitute that for each occurrence of that parameter in the function parameter list, or for a template conversion function, in the return type.
4 Using the transformed function parameter list, perform argument deduction against the other function template. The transformed template is at least as specialized as the other if, and only if, the deduction succeeds and the deduced parameter types are an exact match (so the deduction does not rely on implicit conversions).
5 A template is more specialized than another if, and only if, it is at least as specialized as the other template and that template is not at least as specialized as the first.

PM>> Оба прогнали — ПК, как всегда, прав

LL> Павел объяснил

template<class T>
void fun(T);

template<class T>  // specialization?
void fun(T*);

template<>             // specialization?
void fun(int);

template<>            // specialization?
void fun(int);

void fun(char);    // overloading?

PM>template<class T>
PM>void fun(T);

PM>template<class T>  // specialization? нет, это перегрузка
PM>void fun(T*);

PM>template<>             // specialization? да, это явная (explicit) специализация
PM>void fun(int);

PM>template<>            // specialization? да, повторное объявление той же специалиации
PM>void fun(int);

PM>void fun(char);    // overloading? да, перегрузка нешаблонной функцией
PM>

template<class T>
void fun(T);

template<>
viod fun(int)
{
}

void fun(int);

void g()
{
   fun(10);
}

template<class T>
void fun(T);

template<class T>
void fun(T *);

void g()
{
    fun<int *>(0);
}