一、初识函数模板
1. 定义一个函数模板
template<typename T>
T my_max(T a, T b) {
std::cout << "max" << std::endl;
return a < b ? b : a;
}
2. 使用函数模板
int i_a = 10;
int i_b = 20;
std::cout << ::my_max(i_a, i_b) << std::endl;
const std::string a{"aaa"};
const std::string b{"bbb"};
std::cout << ::my_max(a, b) << std::endl;
long c_a = 'c';
long c_b = 'b';
std::cout << ::my_max(c_a, c_b) << std::endl;
/**
* 其他任意类型，略
*/
我们可以使用任意类型去调用这个模板函数，简单太美妙了。
二、模板的编译和链接
编译
上面的代码里最后有一句注释是说，可以调用任意的类型，其实也不然。对于 class ，如果其不支持比较运算符，那么上面的代码就会有编译错误。所以，这就要讲到模板的编译了。
模板编译分为 2 个阶段：
定义阶段，这个时候是不会检查模板里面的代码的。因为模板还没有被具体实例化。所以这个时候只会检查语法是否符合。
实例化阶段，这个也很好理解，比如上面用 int / std::string / long 类型做参数时，那 my_max() 就会分别定义一个参数的类型为 int / std::string /long 的 my_max() ，然后才会对模板函数的实际内容作编译检查，比如这里会检查所传递的类型是否支持比较运算符。如果不支持就会报错。
链接
三、模板参数类型推断
如果我们再一个 my_max 的参数传引用的实现版本，又会怎么样呢。
template<typename T>
T my_max(T &a, T &b) {
std::cout << "max& " << typeid(a).name() << std::endl;
return a < b ? b : a;
}
如果这个与上面的参数传值同时存在，则编译器会报如下错误：
error: call to 'my_max' is ambiguous
这句话的意思是，这是有一个有岐义的调用。然后再考虑一种情况，当两个参数的类型传不一致时会有什么意外发生。
::my_max(5, 10.5); // 一个是整型，一个是 double 型
此时编译的话会报如下误
error: no matching function for call to 'my_max'
note: candidate template ignored: deduced conflicting types for parameter 'T' ('int' vs. 'double')
意思是没有可匹配的函数可以调用，推断是冲突的。
对的，这就是模板的类型参数推断。上面的错误说明了两个问题：
- 传值和传引用可以同时定义，但不能同时被调用，因为在实例化的阶段，编译器也不知道该实例化哪一个。
- 传参数时，对于单个参数类型的模板，其类型必须一致。否则也实例化不了。
另外，关于模板参数推动还有两个类型转换的问题：
- 如果参数是传引用，则实参类型必须一致。
2.如果参数是传值，则只有退化这一简单原则可以被使用，例如 const int 可以退化成 int。这与上面说的，按不同类型传值会出错的行为是一致的。
三、多个模板参数
既然单模板参数不能传递不同的实参类型，那再加多一个模板参数呢？
template<typename T1,typename T2>
T1 my_max(T1 a, T2 b) {
std::cout << "max,T1 & T2" << std::endl;
return a < b ? b : a;
}
加上如上重载代码后，完美了，没有编译错误，结果也出来了。凡事都有个但是，就是这里的返回值该用 T1 还是 T2 呢。如果用 T1 ，那返回值如果是 b 的话就会发生强制转换，反之亦然。 C++ 里提供了 3 种解决方法：
- 引入第三个参数
template<typename T1,typename T2, typename R>
R my_max(T1 a, T2 b) {
std::cout << "max,double T" << std::endl;
return a < b ? b : a;
}
如果是上面这样的话，那你的调用得这样
::my_max<int, double, int>(5, 10.5);
这就有点麻烦了，必须要全部指定实参类型。这是因为第 3 个参数是不参与函数实例编译的，所以就不会参与类型推断，这就需要我们人为指定了，而且还必须全部指定，这个可就麻烦了。当然 ，你可以通过将返回类型放在第一个。
template<typename R, typename T1,typename T2>
R my_max(T1 a, T2 b) {
std::cout << "max,double T" << std::endl;
return a < b ? b : a;
}
那你的调用就可以变成如下形式。
::my_max<int>(5, 10.5);
- 让编译器自动推断出返回类型
c++ 14 之后，支持使用 auto 关键字来作为返回类型，这简直太方便了有木有，而且调用还和之前是一样的。
template<typename T1,typename T2>
auto my_max(T1 a, T2 b) {
std::cout << "max,auto T" << std::endl;
return a < b ? b : a;
}
- 选择参数的公共类型
c++ 11 的定义
template<typename T1,typename T2>
typename std::common_type<T1, T2>::type my_max(T1 a, T2 b) {
std::cout << "max,common type T" << std::endl;
return a < b ? b : a;
}
c++ 14 的定义
template<typename T1,typename T2>
std::common_type_t<T1, T2> my_max(T1 a, T2 b) {
std::cout << "max,common type T" << std::endl;
return a < b ? b : a;
}
c++14 比 c++11 要简单，但本质上都是 type_traits 技术，这是又一门学问。
四、默认模板参数
默认模板参数与函数的默认参数的概念上是一样的，即你可以在定义模板时，默认指定一个类型，同时你还可以在调用时指定其他的任意类型。不过和函数参数不一样的是，模板默认参数可以通过前面的参数推断出来，如：
template<typename T1,typename T2, typename R=std::decay_t<decltype(true ? T1() : T2())>>
R my_max(T1 a, T2 b) {
std::cout << "max,R by T1 & T2" << std::endl;
return a < b ? b : a;
}
五、模板重载
先看看下面的两个函数，一个使用了模板，一个没有使用模板。这里就发生了模板重载。当然，对于不同模板参数个数的 my_max 也是重载，但那在这里讨论就没有意义。
int my_max(int a, int b) {
std::cout << "max int" << std::endl;
return a > b ? a : b;
}
template<typename T>
T my_max(T a, T b) {
std::cout << "max template" << std::endl;
return a < b ? b : a;
}
然后看看调用
::my_max(5.5, 10.5); // max template
::my_max(5,10); // max int
说明优先调用的是没有模板的函数，这样也符合资源优化的原则。
六、函数模板还有一些问题
- 模板参数可以定义是传值、传引用和传指针，但一般都用传值来定义的。如果在调用时要传递引用，可以使用 std::ref()。
- 函数模板不能使用 inline。
- 函数模板不能使用 constexpr.
