eleven26
0%

C++ 函数模板的实参类型推断

Posted on Edited on

在使用类模板创建对象时，程序员需要显式的指明实参（也就是具体的类型）。例如对于下面的 Point 类：

1
template<typename T1, typename T2> class Point;

我们可以在栈上创建对象，也可以在堆上创建对象。

1
2
Point<int, int> p1(10, 20); // 在栈上创建对象
Point<char*, char*> *p = new Point<char*, char*>("东经180度", "北纬210度"); // 在堆上创建对象

因为已经显式地指明了 T1、T2 的具体类型，所以编译器就不用再自己推断了，直接拿来使用即可。

而对于函数模板，调用函数时可以不显式地指明实参（也就是具体的类型）。请看下面的例子：

1
2
3
4
5
6
7
8
// 函数声明
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);

虽然没有显式地指明 T 的具体类型，但是编译器会根据 n1 和 n2、f1 和 f2 的类型自动推断出 T 的类型。

这种通过函数实参来确定模板实参（也就是类型参数的具体类型）的过程称为模板实参推断。

在模板实参推断过程中，编译器使用函数调用中的实参类型来寻找类型参数的具体类型。

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

对于普通函数（非模板函数），发生函数调用时会对实参的类型进行适当的转换，以适应形参的类型。这些转换包括：

  • 算数转换：例如 int 转换为 float，char 转换为 int，double 转换为 int 等。

  • 派生类向基类的转换：也就是向上转型。

  • const 转换：也即将非 const 类型转换为 const 类型，例如将 char * 转换为 const char *。

  • 数组或函数指针转换：如果函数形参不是引用类型，那么数组名会转换为数组指针，函数名也会转换为函数指针。

  • 用户自定的类型转换。

例如有下面两个函数原型：

1
2
void func1(int n, float f);
void func2(int *arr, const char *str);

它们具体的调用形式为：

1
2
3
4
5
6
int nums[5];
char *url = "http://baidu.com";
// 12.5 会从 double 转换为 int，45 会从 int 转换为 float
func1(12.5, 45);
// nums 会从 int[5] 转换为 int*，url 会从 char* 转换为 const char*
func2(nums, url);

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

例如有下面几个函数模板：

1
2
3
4
5
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);

它们具体的调用形式为：

1
2
3
4
5
6
7
8
int name[20];
Student stu1("CPP", 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]

对于 func1(12.5, 30)，12.5 的类型为 double，30 的类型为 int，编译器不知道该将 T 实例化为 double 还是 int，也不会尝试将 int 转换为 double，或者将 double 转换为 int，所以调用失败。

请读者注意 name，它本来的类型是 int[20]：

  • 对于 func2(name) 和 func4(name)，name 的类型会从 int[20] 转换为 int，也即将数组转换为指针，所以 T 的类型分别为 int 和 int。

  • 对于 func5(name)，name 的类型依然为 int[20]，不会转换为 int*，所以 T 的类型为 int[20]。

可以发现，当函数形参是引用类型时，数组不会转换为指针。这个时候读者要注意下面这样的函数模板：

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

如果它的具体调用形式为：

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

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

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

函数模板的实参推断是指 "在函数调用过程中根据实参的类型来寻找类型参数的具体类型" 的过程，这在大部分情况下是奏效的，但是当类型参数的个数较多时，就会有个别的类型无法推断出来，这个时候就必须显式地指明实参。

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

1
2
3
4
5
template<typename T1, typename T2> void func(T1 a) {
    T2 b;
}

func(10); // 函数调用

func() 有两个类型参数，分别是 T1 和 T2，但是编译器只能从函数调用中推断出 T1 的类型来，不能推断出 T2 的类型来，所以这种调用是失败的，这个时候就必须显式地指明 T1、T2 的具体类型。

"为函数模板显式地指明实参" 和 "为类模板显式地指明实参" 的形式是类似的，就是在函数名后面添加尖括号 <>，里面包含具体的类型。例如对于上面的 func()，我们这样来指明实参：

1
func<int, int>(10);

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

对于上面的 func()，虽然只有 T2 的类型不能自动推断出来，但是由于它位于类型参数列表的尾部，所以必须同时指明 T1 和 T2 的类型。对代码稍微作出修改：

1
2
3
4
5
6
7
template<typename T1, typename T2> void func(T2 a) {
    T1 b;
}

// 函数调用
func<int>(10); // 省略 T2 的类型
func<int, int>(20); // 指明 T1、T2 的类型

由于 T2 的类型能够自动推断出来，并且它位于参数列表的尾部，所以可以省略。

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

上面我们提到，函数模板仅能进行 const 转换和 数组或函数指针转换 两种形式的类型转换，但是当我们显式地指明类型参数的实参时，就可以使用正常的类型转换（非模板函数可以使用的类型转换）了。

例如对于下面的函数模板：

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

它的具体调用形式如下：

1
2
func(10, 23.5); //Error
func<float>(20, 93.7); // Correct

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