1. 函数模板

1
2
3
4
5
6

//max1.hpp
template <typename T>
T max(T a, T b)
{
    return b < a ? a : b;
}

这个模板第一了一系列函数，他们都返回了两个参数中值较大的拿一个。这两个参数的类型并没有确定，而是被表示为 模板参数(template parameter) T 。

模板参数应该按照如下的语法来声明：

template <由逗号分隔的模板参数>

在本例中，模板参数是 typename T 。关键字 typename 标识了一个 类型参数 ，即 T 是 类型参数(type parameter) ，你可以用任意的标识作为类型参数的参数名，但是习惯上我们使用 T 作为参数名。本例中，类型 T 必须支持小于运算符，因为 a 和 b 比较时运用到了它。另外比较隐秘的一点，为了支持返回值， T 还应该是可拷贝的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

//max1.cpp
#include "max1.hpp"
#include <iostream>
#include <string>
int main()
{
    int i = 42;
    std::cout << "max(7,i): " << ::max(7,i) << '\n';
    double f1 = 3.4;
    double f2 = -6.7;
    std::cout << "max(f1,f2): " << ::max(f1,f2) << '\n';
    std::string s1 = "mathematics";
    std::string s2 = "math";
    std::cout << "max(s1,s2): " << ::max(s1,s2) << '\n';
}

注意在调用的 max() 模板的时候使用了作用域限制符 :: 。这样保证了程序将会在全局 命名空间(namespace) 中查找 max() 模板。

在此程序中， max() 被调用了三次：一次是比较两个 int ，一次是比较两个 double ，还有一次是比较两个 std::string 。每一次都会算出最大值。下面是输出结果：

1
2
3

max(7,i): 42
max(f1,f2): 3.4
max(s1,s2): mathematics

在编译阶段，模板并不是被编译成一个可以支持多种类型的实体。而是对每一个用于该模板的类型都会产生一个独立的实体。因此在本例中， max() 会被编译出三个实体，因为它被用于三种类型。比如第一次调用时：

1
2

int i = 42;
... max(7, i) ...

函数模板的类型参数 T 是 int 。因此在语义上等价于调用如下函数：

1
2
3
4

int max(int a, int b)
{
    return b < a ? a : b;
}

以上用具体类型取代模板类型参数的过程叫做 实例化(instantiation) 。它会产生模板的一个实例。

值得注意的是，模板的实例化不需要程序员做额外的请求，只是简单的使用函数模板就会触发这一实例化过程。

同样的，另外两次调用也会分别为 double 和 std::string 各实例化出一个实例，就像是分别定义了下面两个函数一样：

1
2

double max(double, double);
std::string max(std::string, std::string);

另外，只要结果是有意义的，void 作为模板参数也是有效的。比如:

1
2
3
4
5
6

template <typename T>
T foo(T*)
{ }
void* vp = nullptr;
foo(vp); // OK: 模板参数被推导为 void
foo(void*)

1
2
3

std::complex<float> c1, c2; // std::complex<> 没有提供小于运算符
...
::max(c1,c2); // 编译期 ERROR

在编写是不会立刻提醒错误，因为模板是分两步编译的：

1
2
3
4
5
6
7
8
9
10
11

template <typename T>
T max(T a, T b);
...
int i = 1;
int const c = 42;
max(i, c); // OK: T 被推导为 int
max(c, c); // OK: T 被推导为 int
int& ir = i;
max(i, ir); // OK: T 被推导为 int
int arr[4];
max(&i, arr); // OK: T 被推导为 int*

但是像下面这样是错误的：

1
2
3

max(4, 7.2); // ERROR: 不确定 T 该被推导为 int 还是 double
std::string s;
max("hello", s); //ERROR: 不确定 T 该被推导为 const[6] 还是 std::string

有三种办法解决以上错误：

1

max(static_cast<double>(4), 7.2); // OK

1

max<double>(4, 7.2); // OK

当模板参数和调用参数直接没有必然联系，且模板参数不能确定是，就要显式地指明模板参数。例如，你可以引入第三个模板参数来指定函数模板的返回类型：

1
2

template <typename T1, typename T2, typename RT>
RT max(T1 a, T2 b);

但是模板类型推导不会考虑返回类型，而 RT 不是函数的调用参数的类型。因此 RT 不会被推导。这样就必须显式的指明模板参数的类型。比如：

1
2
3
4

template <typename T1, typename T2, typename RT>
RT max(T1 a, T2 b);
...
::max<int,double,double>(4, 7.2); // OK, 但是太繁琐

到目前为止，我们看到的情况是，要么所有模板参数都被显式指定，要么一个都不指定。另一种办法是只指定第一个模板参数的类型，其余参数的类型通过推导获得。通常而言，我们必须显式指定所有模板参数的类型，直到某一个模板参数的类型可以被推导出来为止。因此，如果你改变了上面例子中的模板参数顺序，调用时只需要指定返回值的类型就可以了：

1
2
3
4

template <typename RT, typename T1, typename T2>
RT max(T1 a, T2 b);
...
::max<double>(4, 7.2) //OK: 返回类型是 double，T1 和 T2 根据调用参数推导

在本例中，调用 max<double> 时，显式的指明了 RT 的类型是 double ， T1 和 T2 则基于传入调用参数的类型被推导为 int 和 double 。
然而改进版的 max() 并没有带来显著的变化。使用单模板参数的版本，即使传入的两个调用参数的类型不同，你依然可以显式的指定模板参数类型（也作为返回类型）。因此为了简洁，我们最好还是使用单模板参数的版本。

1
2
3
4
5

template <typename T1, typename T2>
auto max(T1 a, T2 b)
{
	return b < a ? a : b;
}

在 C++14 之前，要想让编译器推导出返回类型，就必须让或多或少的函数实现成为函数声明的一部分。在 C++11 中， 尾置返回类型(trailing return type) 允许我们使用函数的调用参数。也就是说，我们可以基于运算符 ?: 的结果声明返回类型：

1
2
3
4
5

template <typename T1, typename T2>
auto max(T1 a, T2 b) -> decltype(b < a ? a : b)
{
    return b < a ? a : b;
}

在这里，返回类型是由运算符 ?: 的结果决定的，这虽然复杂但是可以得到想要的结果。

需要注意的是

1
2

template <typename T1, typename T2>
auto max(T1 a, T2 b) -> decltype(b < a ? a : b);

是一个声明，编译器在编译阶段会根据 ?: 调用参数 a 和 b 的返回结果来决定实际的返回类型。不过具体实现时不一定需要匹配。所以事实上只要使用 true 作为运算符 ?: 的条件就行了：

1
2

template <typename T1, typename T2>
auto max(T1 a, T2 b) -> decltype(true ? a : b);

但是在某些情况下会有一个严重的问题：由于 T 可能是引用类型，返回类型就也可能被推导为引用类型。因此你应该返回的是 退化(decay) 后的 T ，像下面这样：

1
2
3
4
5
6

#include <type_traits>
template <typename T1, typename T2>
auto max(T1 a, T2 b) -> typename std::decay<decltype(true ? a : b)>::type
{
    return b < a ? a : b;
}

这里用到了 type trait std::decay<> ，它的 type 成员返回目标类型，它定义在标准库 <type_traits> 中。因为其 type 成员是结果类型，为了获取其结果，应该用关键字 typename 来修饰这个表达式。

注意，在初始化 auto 类型是总是 退化(decay) 后的类型。它同样支持返回类型是 auto 。 用 auto 作为返回结果的效果就像下面那样， a 的类型被推导为 i 退化后的类型，即为 int ：

1
2
3

int i = 42;
int const& ir = i; // ir 是 i 的引用
auto a = ir; // a 的类型是 ir decay 之后的类型，也就是int

1
2
3
4
5
6

#include <type_traits>
template <typename T1, typename T2>
std::common_type_t<T1, T2> max(T1 a, T2 b)
{
    return b < a ? a : b;
}

同样的， std::common_type<> 也是一个 type trait ，定义在标准库 type_traits 中，它返回一个结构体，其 type 成员是结果类型。其主要的应用如下：

1

typename std::common_type<T1, T2>::type //since C++11

在C++14后，你可以简化其用法，仅需在后面加一个 _t ，就可以省掉 typename 和 ::type ，简化后的版本变为：

1

std::common_type_t<T1, T2> // equivalent since C++14

std::common_type<> 的实现用到了一些比较取巧的模板编程手法（后续会介绍）。它根据运算符 ?: 的语法规则或者对某些类型的特化来决定目标类型。因此 ::max(4, 7.2) 和 ::max(7.2, 4) 都返回 double 类型的 7.2 。需要注意的是， std::common_type<> 的结果也是 退化(decay) 的。

例如，如果你想像前面叙述的那样是返回类型有多个模板参数，你可以定义一个模板参数 RT ，并将其默认类型声明为其他两个模板的公共类型。同样的我们也有多种实现方法：

1
2
3
4
5
6
7

#include <type_traits>
template <typename T1, typename T2,typename RT = 
          std::decay_t<decltype(true ? T1() : T2())>>
RT max(T1 a, T2 b)
{
    return b < a ? a : b;
}

再有，对于模板，还有一些特殊情况：

后续会对此进行进一步讨论， 除了某些不得不用按引用传递的情况，尽量使用按值传递。

唯一一个例外是模板对某些类型进行了 全特化(full spcializations) ，这时的结果代码不再是 泛型(generic) 的(所有的模板参数都已经被指定了)。后续会详细讨论。

严格地从语言角度来看， inline 只意味着在程序中函数的定义可以出现很多次。不过它也给了编译器一个暗示，在调用该函数的地方函数应该被展开成 inline 的：这样做在某些情况下可以提高效率，但是在另一些情况下也可能降低效率。现代编译器在没有关键字 inline 暗示的情况下，通常也可以很好的决定是否将函数展开成 inline 的。当然，编译器在做决定的时候依然会将关键字 inline 纳入考虑因素。

比如为了可以在编译期使用求最大值的函数，你需要将函数模板定义如下：

1
2
3
4
5

template <typename T1, typename T2>
constexpr auto max(T1 a, T2 b)
{
    return b < a ? a : b;
}

通过此，你可以使用此函数在编译期就求出最大值，例如当定义数列的大小时：

1

int a[::max(sizeof(char), 1000u)];

或者指定 std::array<> 的大小：

1

std::array<std::string, ::max(sizeof(char), 1000u)> arr;

在这里我们传递的 1000 是 unsigned int 类型，这样可以避免直接比较一个有符号数值和一个无符号数值时产生的警报。

后续也会继续讨论 constexpr 。