C++ 函数模板

一、初识函数模板

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')

意思是没有可匹配的函数可以调用，推断是冲突的。

对的，这就是模板的类型参数推断。上面的错误说明了两个问题：

1. 传值和传引用可以同时定义，但不能同时被调用，因为在实例化的阶段，编译器也不知道该实例化哪一个。
2. 传参数时，对于单个参数类型的模板，其类型必须一致。否则也实例化不了。

另外，关于模板参数推动还有两个类型转换的问题：

1. 如果参数是传引用，则实参类型必须一致。
   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 种解决方法：

1. 引入第三个参数

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);

2. 让编译器自动推断出返回类型
   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;
}

3. 选择参数的公共类型
   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

说明优先调用的是没有模板的函数，这样也符合资源优化的原则。

六、函数模板还有一些问题

1. 模板参数可以定义是传值、传引用和传指针，但一般都用传值来定义的。如果在调用时要传递引用，可以使用 std::ref()。
2. 函数模板不能使用 inline。
3. 函数模板不能使用 constexpr.