C++ 初识函数模板

typedef int(*PF)(int,int); // 1 
PF pf=getMin;  // 2
int res= pf(6,8);  //3
cout<

• 1
• 2
• 3
• 4

说明：

• 1 处先定义一个函数指针类型。

• 2 处这行代码，千万不要理解是取函数模板的地址，编译器在底层做了相应处理。

  编译器会根据函数指针类型说明先实例化一个函数。

  再取实例化函数的内存地址，并赋值给 pf。

• 3 处以函数指针方式调用函数。

实例化时要注意的几个问题：

1. 实例化时，可能会有一个直观问题：真的能指定任意一种数据类型实例化函数模板吗？

答案是：任何高级层面的逻辑行为都不能脱离基础知识的认知范畴，不同的数据类型有着语法系统赋予它的运算操作能力，当指定一个不支持函数模板内部算法操作的数据类型时，必然会出错。

如声明一个求 2 个数字相除的余数的函数模板。

template T getYuShu(T num1,T num2) {
	return num1 % num2;
}
1
2
3

如果指定 double 数据类型实例化 getYuShu 函数模板时，就会抛出错误，因为 double数据类型不能使用 %运算符。

double res=getYuShu(6.2,2.4);  //出错
1

Tips： 编译器在实例化函数模板时，会遵循语法标准检查给定的数据类型是否支持函数模板中的运算操作。

2. 编译器实例化的时机。

常规而言，编译器会在程序中第一次需要函数模板的某个实例时对其进行编译。但是，同一份代码中，可能会出现对同一个实例多次调用的需要，如下面的代码：

template  test(T num) {
	return num;
}
int f() {
	int res= test(12);
	return res;
}
double f1() {
	int res= test(24);
	return double(res);
}
1
2
3
4
5
6
7
8
9
10
11

f和f1函数都需要使用 test实例，于编译器而，无法知道 f和f1函数谁先会被调用（也就无法确定第一次编译的时间点），但为了保证编译期间完成实例化工作，早期C++编译器采用对同一实例每一次出现的地方都编译的策略，然后从多个编译结果中选一个作为最终结果，显然，编译时间会大大延长。

C++充许显式实例化声明，用来显示指定某一个函数模板的实例化的时间点，从而解决同一个实例被多次编译的问题。其语法如下：

template 返回值类型 模板名<模板参数列表>(函数形参列表);
1

针对上述函数模板可以编写如下代码，告之编译器编译时间点。

template  test(T num) {
	return num;
}
//显示指定实例化
template int test(int);
1
2
3
4
5

Tips： 显示声明只对一个源文件有效。

2.3 实参推导

所谓实参推导，在使用函数模板时省略<>，不明确指定数据类型参数，而是由编译器根据函数的实参类型自动推导出类型参数的真正类型。如下代码：

int res=getMin(4,7);
1

实参是int 类型， 编译器由此推导出 T 是 int类型，从而使用 int类型实例化函数模板，类似于下面的显示声明代码：

int res=getMin(4,7);
1

实参推导可以像调用普通函数一样使用函数模板。但是实参推导是有前提条件的：函数参数使用了类型参数的才能通过函数实参类型推导。如下的函数模板。

template  T2 myMax(T1 num1,T1 num2) {
	//函数体
}
1
2
3

因为 T2是作为函数模板的返回类型，是无法通过实参类型推导出来的。如下图所示：

使用如上函数模板，需要显示指定具体的数据类型。

double res= myMax(6,8); //正确
1

是否可以让函数模板的类型参数一部分显示指定，一部分由实参推导？

答案是可以，但是，要求在声明函数模板时，把需要显示指定的类型参数放在前面，可由实参推导的参数类型放在后面。把上面的函数模板的 T1、T2参数说明交换位置。

template  T2 myMax(T1 num1,T1 num2) {
	//函数体
}
1
2
3

实例化时，只需要显示指定 T2的类型，T1类型由编译器根据实参推导。如下代码可正确调用。

double res= myMax(6,8); //正确
1

编译器把 T2指定为 double类型，然后根据实参6和8推导出 T1是 int类型。

了解什么是实参推导后，使用时，需要知道实参推导是不支持自动类型转换的。如下代码是错误的。

int res=getMin(4,7.5); //错误
1

编译器认定实参 4是int类型，实参7.5是 double类型，那么是到底是使用 int 类型还是使用 double类型实例化 getMin 函数模板，会让编译器不知所措、左右为难。

Tips： 即使支持自动类型转换，于编译器而言也无法知道开发者是想使用 int 类型还是 double 类型。如此自动类型转换没有存在的意义。

对于上述问题可以采用如下几种方案解决：

• 通过强制类型操作把实参转换成统一数据类型。

  int res=getMin(4,int(7.5));
  或者
  int res=getMin(double(4),7.5);
  1
  2
  3

• 显示指定实例化时的数据类型。

  int res=getMin(4,7.5);
  //或者
  int res=getMin(4,7.5);
  1
  2
  3

• 如果有必要传递 2 个不同类型的参数，可需要修改函数模板，使其能接受 2 种类型参数。

  template T1 getMin(T1 num1,T2 num2){
  	return num1>num2?num2:num1; 
  } 
  1
  2
  3

3. 重载函数模板

C++中普通函数和函数模板可以一起重载，面对多个重载函数，编译器需要提供相应的匹配策略。如下代码：

//普通函数
int getMax(int num1,int num2){
	return num1>num2?num1:num2; 
} 
//函数模板
template T getMax(T num1,T num2) {
	return num1>num2?num1:num2;
}
1
2
3
4
5
6
7
8

如下调用时，编译器是选择普通函数还是函数模板？

int res= getMax(6,8);
1

函数实参是 int类型，相比较函数模板，普通函数不需要实例化可直接使用，编译器会优先选择普通函数。但是如下的调用，编译器会选择函数模板。

getMax(2.4,6.8); //调用 getMax(实参推导)
getMax('a','b'); //调用 getMax(实参推导)
getMax<>(7,3) //调用 getMax (实参推导)
getMax(4,9) //显示指定
1
2
3
4

编译器选择函数模板的原则：

• 如果函数模板能实例出一个完全与函数实参类型相匹配的函数，那么就会选择函数模板，如getMax(2.4,6.8); 调用。编译器会根据函数模板实例化一个double getMax(double a,double b)函数与需求完全相匹配的函数。
• 如果即想使用实参推导，且想使用函数模板而非普通函数，可以使用空 <>尖括号语法。如上的 getMax<>(7,7); 调用。一旦指定<>标识符，显示指定使用函数模板，无论其中是否有实参类型说明。

如下的函数调用，实参有 2 个，但 2者之间可以发生自动类型转换。

char和int之间可以相互转换。

getMax('a',98);
1

编译器会选择谁？可以做一个实验，把普通函数注释，保留函数模板。

#include 
#include 
using namespace std;
//函数模板
template T getMax(T num1,T num2) {
	return num1>num2?num1:num2;
}
int main(int argc, char** argv) {
    int t= getMax('a',98)
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

执行后：

再恢复普通函数后执行，代码可以正常执行。显然，编译器选择的是普通函数。原因很简单，在使用实参推导时，函数模板是不支持自动类型转换，而普通函数表示没有压力。

总结一下，选择时，编译器会先考虑有没有类型完全相匹配的普通函数，没有，试着看能不能实例化一个完全匹配的函数。

4. 总结

本文只讲到了函数模板的语法、实例化和重载 3 个方面的内容，除此之外，函数模板还有其它高级应用，受限于篇幅，本文仅抛砖引玉，有兴趣者可以查阅相关文档。