C++ 函数模板的重载与实参推断

    结合网上的资料，对函数模板的重载与实参推断做一个总结。

函数模板的重载

  当需要对不同的类型使用同一种算法时，为了避免定义多个功能重复的函数，可以使用模板。然而，并非所有的类型都使用同一种算法，有些特定的类型需要单独处理，为了满足这种需求，C++允许对函数模板进行重载。

  例如，当交换基本类型和交换两个数组时，虽然功能都是交换，但是使用的方法却不相同，交换两个数组唯一的办法就是逐个交换所有的数组元素。

template<class T> void Swap(T &a, T &b){
    T temp = a;
    a = b;
    b = temp;
}
template<typename T> void Swap(T a[], T b[], int len){
    T temp;
    for(int i=0; i<len; i++){
        temp = a[i];
        a[i] = b[i];
        b[i] = temp;
    }
}

函数模板的实参

  在使用类模板创建对象时，需要显式的指明实参，例如：

template<typename T1, typename T2> class Point;
Point<int, int> p1(10, 20);  //在栈上创建对象
Point<char*, char*> *p = new Point<char*, char*>("东京180度", "北纬210度");  //在堆上创建对象

对于函数模板，调用函数时可以不显式的指明实参，编译器会自动推导出T的类型，例如：

//函数声明
template<typename T> void Swap(T &a, T &b);
//函数调用
int n1 = 100, n2 = 200;
Swap(n1, n2);
float f1 = 12.5, f2 = 56.93;
Swap(f1, f2);

模板实参推断过程中的类型转换

普通函数调用时的类型转换

• 算数转换：例如 int 转换为 float，char 转换为 int，double 转换为 int 等。
• 派生类向基类的转换：也就是向上转型，
• const 转换：也即将非 const 类型转换为 const 类型，例如将 char * 转换为 const char *。
• 数组或函数指针转换：如果函数形参不是引用类型，那么数组名会转换为数组指针，函数名也会转换为函数指针。
• 用户自定的类型转换。

例如：

void func1(int n, float f);
void func2(int *arr, const char *str);
int nums[5];
char *url = "http://c.biancheng.net";
func1(12.5, 45);
func2(nums, url);

  对于 func1()，12.5 会从double转换为int，45 会从int转换为float；对于 func2()，nums 会从int [5]转换为int *，url 会从char *转换为const char *。

函数模板调用时的类型转换

  对于函数模板，类型转换收到了更多的限制，仅能进行[const 转换]和[数组或函数指针转换],其他都不能应用于函数模板。

template<typename T> void func1(T a, T b);
template<typename T> void func2(T *buffer);
template<typename T> void func3(const T &stu);
template<typename T> void func4(T a);
template<typename T> void func5(T &a);

int name[20];
Student stu1("张华", 20, 96.5);  //创建一个Student类型的对象
func1(12.5, 30);  //Error
func2(name);  //name的类型从 int [20] 换转换为 int *，所以 T 的真实类型为 int
func3(stu1);  //非const转换为const，T 的真实类型为 Student
func4(name);  //name的类型从 int [20] 换转换为 int *，所以 T 的真实类型为 int *
func5(name);  //name的类型依然为 int [20]，不会转换为 int *，所以 T 的真实类型为 int [20]

可以发现，当函数形参是引用类型时，数组不会转换为指针。

template<typename T> void func(T &a, T &b);

int str1[20];
int str2[10];
func(str1, str2);

  由于str1、str2的类型分别为int [20]和int [10]，在函数调用过程中又不会转换为指针，所以编译器不知道应该将T实例化为int [20]还是int [10],导致调用失败

为函数模板显式地指明实参

  下面是一个实参推断失败的例子：

template<typename T1, typename T2> void func(T1 a){
    T2 b;
}
func(10);  //函数调用

func()有两个类型参数，分别是T1和T2，但是编译器只能推断出T1，不能推断出T2，调用失败

  显示指明的模板实参会按照从左到右的顺序与对应的模板参数匹配：第一个实参与第一个模板参数匹配，第二个实参与第二个模板参数匹配，只有尾部（最右）的类型参数的实参可以省略，而且前提是它们可以从传递给函数的实参中推断出来。 例如：

template<typename T1, typename T2> void func(T2 a){
    T1 b;
}
//函数调用
func<int>(10);  //省略 T2 的类型
func<int, int>(20);  //指明 T1、T2 的类型

显式的指明实参时可以应用正常的类型转换

  函数模板仅能进行[ const 转换 ]和[ 数组或函数指针转换 ]两种形式的类型转换，但是当我们显式的指明类型参数的实参时，就可以使用正常的类型转换了。例如：

template<typename T> void func(T a, T b);
func(10, 23.5);  //Error
func<float>(20, 93.7);  //Correct

  在第二种调用形式中，我们已经显式地指明了T的类型为float，编译器不会再为T的类型到底是int还是double而纠结了，所以可以从容地使用正常地类型转换了。