六、模板
模板(template)是一种类或者函数，我们用一组类型或值去参数化它。 我们用模板表示这样一种概念：它是某种通用的东西，我么可以通过指定参数来生成类型或函数，至于这种参数，比方说是vector的元素类型double。
❶
我们那个承载double的vector，可以泛化成一个承载任意类型的vector，只要把它变成一个template，并用一个类型参数替代具体的double类型。例如：
template<typename T>
class Vector {
private:
T* elem; // elem指向一个数组，该数组承载sz个T类型的元素
int sz;
public:
explicit Vector(int s); // 构造函数：建立不变式，申请资源
~Vector() { delete[] elem; } // 析构函数：释放资源
// ... 复制和移动操作 ...
T& operator[](int i); // 为非const Vector取下标元素
const T& operator[](int i) const; // 为const Vector取下标元素
int size() const { return sz; }
};
成员函数可能有相似的定义：
template<typename T> Vector<T>::Vector(int s) {
if (s<0)
throw Negative_size{};
elem = new T[s];
sz = s;
}
template<typename T>
const T& Vector<T>::operator[](int i) const {
if (i<0 || size()<=i)
throw out_of_range{"Vector::operator[]"};
return elem[i];
}
想让我们的Vecor支持区间-for循环，就必须定义适当的begin()和end()函数：
template<typename T>
T* begin(Vector<T>& x) {
return x.size() ? &x[0] : nullptr; // 指向第一个元素的指针或者nullptr
}
template<typename T>
T* end(Vector<T>& x) {
return x.size() ? &x[0]+x.size() : nullptr; // 指向末尾元素身后位置
}
模板是个编译期机制，因此使用它们跟手写的代码相比，并不会在运行时带来额外的负担。 实际上，Vector<double>生成的代码与第4章Vector版本的代码一致。 更进一步，标准库vector<double>生成的代码很可能更好 （因为实现它的时候下了更多功夫）。
模板附带一组模板参数，叫做 实例化(instantiation) 或者 特化(specialization)。编译过程靠后的部分，在 实例化期(instantiation time)，程序里用到的每个实例都会被生成。生成的代码会经历类型检查，以便它们与手写代码具有同样的类型安全性。 遗憾的是，此种类型检查通常处于编译过程较晚的阶段——在实例化期。
❷
除了类型参数，模板还可以接受值参数。例如：
template<typename T, int N>
struct Buffer {
using value_type = T;
constexpr int size() { return N; }
T[N];
// ...
};
别名（value_type）和 constexpr 函数允许我们（只读）访问模板参数。
值参数在很多语境里都很有用。例如：Buffer允许我们创建任意容量的缓冲区，却不使用自由存储区（动态内存）：
Buffer<char,1024> glob; // 用于字符的全局缓冲区（静态分配）
void fct() {
Buffer<int,10> buf; // 用于整数的局部缓冲区（在栈上）
// ...
}
值模板参数必须是常量表达式。
❸
考虑一下标准库模板pair的应用：
pair<int,double> p = {1,5.2};
auto p = make_pair(1,5.2); // p 是个 pair<int,double>
pair p = {1,5.2}; // p 是个 pair<int,double>
template<typename T>
class Vector {
public:
Vector(int);
Vector(initializer_list<T>); // 初始化列表构造函数
// ...
};
Vector v1 {1,2,3}; // 从初始值类型推导v1的元素类型
Vector v2 = v1; // 从v1的元素类型推导v2的元素类型
auto p = new Vector{1,2,3}; // p 指向一个 Vector<int>
Vector<int> v3(1); // 此处，我们需要显式指定元素类型（未提及元素类型）
Vector<string> vs1 {"Hello", "World"}; // Vector<string>
Vector vs {"Hello", "World"}; // 推导为 Vector<const char*> （诧异吗？）
Vector vs2 {"Hello"s, "World"s}; // 推导为 Vector<string>
Vector vs3 {"Hello"s, "World"}; // 报错：初始化列表类型不单一
如果无法从构造函数参数推导某个模板参数，我们可以用 推导引导 辅助。考虑：
template<typename T>
class Vector2 {
public:
using value_type = T;
// ...
Vector2(initializer_list<T>); // 初始化列表构造函数
template<typename Iter>
Vector2(Iter b, Iter e); // [b:e) 区间构造函数
// ...
};
Vector2 v1 {1,2,3,4,5}; // 元素类型是 int
Vector2 v2(v1.begin(),v1.begin()+2);// 元素类型是 int，而非 Iterator
很明显，v2应该是个Vector2<int>，但是因为缺少辅助信息，编译器无法推导出来。 这段代码仅表明：有个构造函数接收一对同类型的值。 缺乏概束的语言支持，对于该类型，编译器无法假设任何情况。 如果想进行推导，可以在Vector2的声明后添加一个推导指引：
template<typename Iter>
Vector2(Iter,Iter) -> Vector2<typename Iter::value_type>;
推导指引的效果通常很微妙，因此在设计类模板的时候，尽量别依靠它。 不过，标准库里满是（目前还）未使用concept且带有这种二义性的类， 因此它们用了不少的推导指引。
❹
template<typename Sequence, typename Value>
Value sum(const Sequence& s, Value v) {
for (auto x : s)
v+=x;
return v;
}
模板参数Value和函数参数v，允许调用者指定这个累加函数的类型和初值（累加到和里的变量）：
void user(Vector<int>& vi, list<double>& ld, vector<complex<double>>& vc) {
int x = sum(vi,0); // 承载 int 的vector的和（与 int 相加）
double d = sum(vi,0.0); // 承载 int 的vector的和（与 double 相加）
double dd = sum(ld,0.0); // 承载 double 的vector的和
auto z = sum(vc,complex{0.0,0.0}); // 承载 complex<double>s 的vector的和
}
把int加到double上的意义在于能优雅地处理超出int上限地数值。注意sum<Sequence,Value>从函数参数中推导模板参数的方法。巧的是不需要显式指定它们。
函数模板可用于成员函数，但不能是virtual成员。在一个程序里，编译器无法知晓某个模板的全部实例，因此无法生成虚函数表vtbl。
❺
有一种特别有用的模板是函数对象(function object)（也叫仿函数(functor)），用于定义可调用对象。例如：
template<typename T>
class Less_than {
const T val; // 参与比对的值
public:
Less_than(const T& v) :val{v} { }
bool operator()(const T& x) const { return x<val; } // 调用运算符
};
名为operator()的函数实现“函数调用”、“调用”或“应用”运算符()。
可以为某些参数类型定义Less_than类型的具名变量：
Less_than lti {42}; // lti(i) 将把i用<号与42作比（i<42）
Less_than lts {"Backus"s}; // lts(s) 将把s用<号与"Backus"作比（s<"Backus"）
Less_than<string> lts2 {"Naur"}; // "Naur"是个C风格字符串，因此需要用 <string> 获取正确的 <
可以像调用函数一样调用这样的对象：
void fct(int n, const string& s) {
bool b1 = lti(n); // true if n<42
bool b2 = lts(s); // true if s<"Backus"
// ...
}
这种函数对象广泛用做算法的参数。例如，可以统计使特定谓词为true的值的数量：
template<typename C, typename P>
// requires Sequence<C> && Callable<P,Value_type<P>>
int count(const C& c, P pred) {
int cnt = 0;
for (const auto& x : c)
if (pred(x))
++cnt;
return cnt;
}
谓词(predicate)是调用后能返回true或false的东西。例如：
void f(const Vector<int>& vec, const list<string>& lst, int x, const string& s) {
cout << "number of values less than " << x << ": " << count(vec,Less_than{x}) << '\n';
cout << "number of values less than " << s << ": " << count(lst,Less_than{s}) << '\n';
}
这些函数对象的妙处在于，它们随身携带参与比较的值。 我们无需为每个值（以及每种类型）写一个单独的函数，也无需引入一个恼人的全局变量去持有这个值。还有，类似于Less_than这种函数对象易于内联，因此调用Less_than远比间接的函数调用高效。携带数据的能力再加上高效性，使函数对象作为算法参数特别有用。
用在通用算法中的函数对象，可指明其关键运算的意义（例如Less_than之于count()），通常被称为策略对象(policy object)。
❻
还有个隐式生成函数对象的写法：
void f(const Vector<int>& vec, const list<string>& lst, int x, const string& s) {
cout << "number of values less than " << x
<< ": " << count(vec,[&](int a){ return a<x; })
<< '\n';
cout << "number of values less than " << s
<< ": " << count(lst,[&](const string& a){ return a<s; })
<< '\n';
}
[&](int a){return a<x;}这个写法叫lambda表达式。 它跟Less_than<int>{x}一样会生成函数对象。此处的[&]是一个抓取列表(capture list)，表明lambda函数体内用到的所有局部名称，将以引用的形式访问。如果我们仅想“抓取”x，应该这么写：[&x]。如果我们把x的副本传给生成的对象，就应该这么写：[=x]。不抓取任何东西写[ ]，以引用方式抓取所有局部名称写[&]，以传值方式抓取所有局部名称写：[=]。
使用lambda表达式方便、简略，但也略晦涩些。 对于繁复的操作（比方说超出一个表达式的内容），我倾向于为它命名，以便明确用途，并让它可以在程序中多处访问。
再来看一个示例：
template<typename C, typename Oper>
void for_all(C& c, Oper op) {// 假定C是个承载指针的容器
// 要求 Sequence<C> && Callable<Oper,Value_type<C>>
for (auto& x : c)
op(x); // 把每个元素指向的对象传引用给 op()
}
void user2() {
vector<unique_ptr<Shape>> v;
while (cin)
v.push_back(read_shape(cin));
for_all(v,[](unique_ptr<Shape>& ps){ ps->draw(); }); // draw_all()
for_all(v,[](unique_ptr<Shape>& ps){ ps->rotate(45); }); // rotate_all(45)
}
我把unique_ptr<Shape>&传给lambda表达式，这样for_all()就无需关心对象存储的方式了。确切的说，这些for_all()函数不影响传入的Shape生命期，lambda表达式的函数体使用参数时，就像用旧式的指针一样。
跟函数一样，lambda表达式也可以泛型。例如：
template<class S>
void rotate_and_draw(vector<S>& v, int r) {
for_all(v, [](auto& s){ s->rotate(r); s->draw(); });
}
此处的auto，像变量声明里那样，意思是初始值（在调用中，实参初始化形参）接受任何类型。这让带有auto的lambda表达式成了模板，一个泛型lambda。
可以用任意容器调用这个泛型的rotate_and_draw()， 只要该容器内的对象能执行draw()和rotate()。例如：
void user4() {
vector<unique_ptr<Shape>> v1;
vector<Shape*> v2;
// ...
rotate_and_draw(v1, 45);
rotate_and_draw(v2, 90);
}
❼
要定义出好的模板，我们需要一些辅助的语言构造：
- 依赖于类型的值：
变量模板(variable template) - 针对类型和模板的别名：
别名模板(alias template) - 编译期选择机制：
if constexpr - 针对类型和表达式属性的编译期查询机制：
requires表达式
另外，constexpr函数和static_assert也经常参与模板设计和应用。
对于构建通用、基本的抽象，这些基础机制是主要工具。
在使用某个类型时，经常会需要该类型的常量和值。这理所当然也发生在我们使用类模板的的时候： 当我们定义了C<T>，通常会需要类型T以及依赖T的其它类型的常量和变量。以下示例出自一个流体力学模拟[Garcia,2015]：
template <class T>
constexpr T viscosity = 0.4;
template <class T>
constexpr space_vector<T> external_acceleration = { T{}, T{-9.8}, T{} };// space_vector是个三维向量
auto vis2 = 2*viscosity<double>;
auto acc = external_acceleration<float>;
显然，可以用适当类型的任意表达式作为初始值。考虑：
template<typename T, typename T2>
constexpr bool Assignable =
is_assignable<T&,T2>::value; // is_assignable 是个类型 trait
template<typename T>
void testing() {
static_assert(Assignable<T&,double>, "can't assign a double");
static_assert(Assignable<T&,string>, "can't assign a string");
}
经历一些大刀阔斧的变动，这个点子成了概束（第7章）定义的关键。
出人意料的是，为类型或者模板引入一个同义词很有用。 例如，标准库头文件<cstddef>包含一个size_t的别名，可能是这样：
using size_t = unsigned int;
用于命名size_t的实际类型是实现相关的，因此在另一个实现里size_t可能是unsigned long。有了别名size_t的存在，就让程序员能够写出可移植的代码。
对参数化类型来说，为模板参数相关的类型提供别名是很常见的。例如：
template<typename T>
class Vector {
public:
using value_type = T;
// ...
};
实际上，每个标准库容器都提供了value_type作为其值类型的名称（第11章）。 对于所有遵循此惯例的容器，我们都能写出可行的代码。例如：
template<typename C>
using Value_type = typename C::value_type; // C 的元素的类型
template<typename Container>
void algo(Container& c) {
Vector<Value_type<Container>> vec; // 结果保存在这里
// ...
}
通过绑定部分或全部模板参数，可以用别名机制定义一个新模板。例如：
template<typename Key, typename Value>
class Map {
// ...
};
template<typename Value>
using String_map = Map<string,Value>;
String_map<int> m; // m 是个 Map<string,int>
思考编写这样一个操作，它在slow_and_safe(T)和simple_and_fast(T)里二选一。这种问题充斥在基础代码中——那些通用性和性能优化都重要的场合。传统的解决方案是写一对重载的函数，并基于trait（第13章）选出最适宜的那个，比方说标准库里的is_pod。如果涉及类体系，slow_and_safe(T)可提供通用操作， 而某个继承类可以用simple_and_fast(T)的实现去重载它。
在 C++17 里，可以利用一个编译期if：
template<typename T> void update(T& target) {
// ...
if constexpr(is_pod<T>::value)
simple_and_fast(target); // 针对“简单旧式的数据”
else
slow_and_safe(target);
// ...
}
is_pod<T>是个类型trait，它辨别某个类型可否低成本复制。
仅被选定的if constexpr分支被实例化。此方案即提供了性能优化，又实现了优化的局部性。
重要的是，if constexpr并非文本处理机制，不会破坏语法、类型和作用域的常见规则。例如：
template<typename T>
void bad(T arg) {
if constexpr(Something<T>::value)
try {// 语法错误
g(arg);
if constexpr(Something<T>::value)
} catch(...) { /* ... */ }// 语法错误
}
如果允许类似的文本操作，会严重破坏代码的可靠性，而且对依赖于新型程序表示技术 （比方说“抽象语法树（abstract syntax tree）”）的工具，会造成问题。
忠告
[1] 可应用于很多参数类型的算法，请用模板去表达；
[2] 请用模板去表达容器；
[3] 请用模板提升代码的抽象层级；
[4] 模板是类型安全的，但它的类型检查略有些迟滞；
[5] 让构造函数或者函数模板去推导模板参数类型；
[6] 使用算法的时候，请用函数对象作参数；
[7] 如果需要简单的一次性函数对象，采用lambda表达式；
[8] 虚成员函数无法作为模板成员函数；
[9] 用模板别名简化符号表示，并隐藏实现细节；
[10] 使用模板时，确保其定义（不仅仅是声明）在作用域内；
[11] 模板提供编译期的“鸭子类型（duck typing）”；
[12] 模板不支持分离编译：把模板定义#include进每个用到它的编译单元。
