overloadresolution, C++ (clang)

Language: Layout:

//g++  4.9.3

#include <iostream>

//=======================================================
//问题1
//函数模板特化的时候，特化的版本，参数类型必须与主模板匹配
template<typename T>
inline T sq(const T& x)
{
    return x*x;
}

//以下的特化版本是合法的，此时T对应于int, 参数 const int&
template<>
inline int sq(const int& i)
{
    return i*i*i;
}

//这个特化版本是非法的，因为参数类型不匹配
//应该将主模板的参数当做一个整体，那么 'const T&’ 无论 'T'
//是什么类型，这个整体都不可能是'double',也就是说特化版本
//是无论如何不可能匹配主模板参数的类型，那自然无法通过编译
//解决方案之一是将函数的参数类型改为'const double&'
//第二种方案就是去掉特化，改成一个重载函数。
//template<>
//inline double sq(double d)
//{
//    return d*d*d*d;
//}

//=======================================================
//问题2
//这是一个小问题，就是特化的时候 'const' 修饰的对象需要搞清楚
//必要时要调整const的位置
template<typename T>
void f(const T& x)
{
    std::cout << "I am f(referemce)" << std::endl;
}

//主模板的const 修饰的是'T',而下面的特化本意是用'int*' 替换'T'
//换句话说const 应该修饰'int*', 这样才可能匹配主模板
//但是'const int*&' 这种写法却是将const 用来修饰'int'
//因此是无法通过编译的
//template<>
//void f(const int*& x)
//{
//    std::cout << "I am f(const int*& x)" << std::endl;
//}

//调整const的位置就符合主模板的本意了。
template<>
void f( int* const&)
{
    std::cout << "I am f(int* const&)" << std::endl;
}

//=======================================================
//问题3
template<typename T>
void g(const T& x)
{
    std::cout << "g(const T& x)" << std::endl;
}

template<typename T>
void g(const T* x)
{
    std::cout << "g(const T* x)" << std::endl;
}

template<typename T>
void g(T* x)
{
    std::cout << "g(T* x)" << std::endl;
}

void g(const char* x)
{
    std::cout << "g(const char* x)" << std::endl;
}

void g(char* x)
{
    std::cout << "g(char* x)" << std::endl;
}

void callg()
{
    char a[] = "sample";
    g(a);
}

int main()
{
    int a = 2;
    
    f(&a);
    
    callg();
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 0.52 sec, absolute running time: 0.13 sec, cpu time: 0 sec, memory peak: 3 Mb, absolute service time: 0,66 sec