模板与泛型编程：从重复代码到可检查接口
项目里常会出现两类相似的重复。第一类是同一段判断被复制给 int、double 和 std::string，函数体几乎没变；第二类是同一种小容器被复制成整数版、字符版，只有元素类型和容量不同。
模板处理的正是这类变化：先保留稳定的操作结构，再把类型、编译期值或策略留成参数。它不会让一段代码神奇地适用于所有类型。模板体用了哪些操作，实参类型就必须支持哪些操作。
理解模板时，最有用的心智模型不是“运行时挑一个分支”，而是“编译器拿到具体实参后形成一个具体版本”。这会直接解释很多问题：为什么错误常在调用处才出现，为什么模板定义通常放在头文件，为什么 SmallBuffer<int, 4> 与 SmallBuffer<int, 8> 是不同类型。
下面从一段重复比较代码出发，逐步建立函数模板、类模板、推导、重载、特化和参数包的完整认识。所有可运行示例都以 C++17 为基准。
从重复比较到函数模板
先找真正变化的部分
假设程序需要三路比较：左值更小返回 -1，右值更小返回 1，相等返回 0。直接写两个版本并不难：
cpp
int compare_int(int lhs, int rhs) {
if (lhs < rhs) return -1;
if (rhs < lhs) return 1;
return 0;
}
int compare_double(double lhs, double rhs) {
if (lhs < rhs) return -1;
if (rhs < lhs) return 1;
return 0;
}两个函数的控制流程完全相同，只有形参类型不同。把类型抽成模板参数后，只保留一份函数体：
cpp
template<typename T>
int compare_values(const T& lhs, const T& rhs) {
if (lhs < rhs) return -1;
if (rhs < lhs) return 1;
return 0;
}template<typename T> 声明类型参数 T。这里的 typename 可以换成 class，含义不变。T 既能代表内建类型，也能代表类、指针或其他满足要求的类型。
这个模板只使用 <，没有同时索取 > 和 ==。第二次比较交换了两个实参，因此一个严格的“小于”操作就够了。泛型接口少要求一个操作，就能多接纳一类合法类型。
把比较规则也留成参数
有时类型相同，排序规则却不同。可以再加入一个策略参数，并给它默认模板实参：
cpp
#include <functional>
#include <iostream>
#include <string>
template<typename T, typename Compare = std::less<T>>
int compare_values(const T& lhs, const T& rhs, Compare comp = Compare{}) {
if (comp(lhs, rhs)) return -1
输出：
text
-1
1
0三次调用分别形成 compare_values<int>、compare_values<double> 和 compare_values<std::string>。Compare 没有从省略掉的第三个函数实参获得推导信息，所以编译器采用默认模板实参 std::less<T>。
实例化不是运行时分支
可以用四步理解 compare_values(7, 11)：
编译器把两个函数实参与形参模式对照，推导出类型参数
T 为 int。省略的策略参数采用默认模板实参，于是
Compare 为 std::less<int>。编译器把参数代入模板，检查
comp(lhs, rhs)、返回语句和构造默认比较器等表达式是否成立。程序确实需要这个版本时，编译器为具体特化生成可调用代码；运行时不会再判断
T 是什么。“替换后再检查”解释了模板错误的时机。模板定义看起来可以成立，但某次调用代入不支持比较的类型后，具体实例才会失败。
compare_values(7, 11) 在编译期推导 T 和默认比较器，完成替换与语义检查后生成具体可调用版本；这不是运行时分支，模板定义通常须在实例化点可见。为什么定义通常放在头文件
普通函数的调用点只需要声明，函数体可以留给链接阶段。隐式实例化模板时，编译器必须看到完整定义，才能替换参数并检查函数体。因此，跨多个翻译单元使用的模板通常把完整定义放在头文件中。
如果程序只允许一组固定类型，也能在实现文件中显式实例化这些版本，再在头文件中配合显式实例化声明。那是一种有意限制可用类型集合的组织方式，不是“任意模板都能像普通函数一样只暴露声明”。
函数模板不是一组运行时重载开关。模板实参在编译期确定；每个具体特化会独立检查。某个类型能使用模板，不代表另一个类型也一定能使用。
小节测试
1.1
三路比较只调用两次同一个小于比较器，最直接的好处是什么？
1.2
只在头文件中声明一个函数模板，而把通用定义隐藏在实现文件中，通常足以支持任意新类型的隐式实例化。
类型参数、值参数与默认实参
模板参数不只代表类型
typename T 是类型模板参数。模板还可以接收编译期值，常见用途是把固定容量或数组长度放进类型：
cpp
#include <cstddef>
template<typename T, std::size_t N>
struct FixedBlock {
T elements[N];
constexpr std::size_t size() const noexcept { return N; }
};
FixedBlock<int, 4> counters{};
FixedBlock<double, 4> samples{};
FixedBlock<int这里的 T 是类型参数，N 是非类型模板参数。三条定义形成三个具体类型：元素类型不同会得到不同类型，容量不同也会得到不同类型。
非类型模板实参必须能在编译期确定：
cpp
constexpr std::size_t packet_size = 32;
FixedBlock<unsigned char, packet_size> packet{}; // 正确
void make_block(std::size_t runtime_size) {
// FixedBlock<int, runtime_size> bad{}; // 错误：运行时值不能形成模板实参
}函数参数决定一次运行中的数据，模板参数决定要形成哪一个函数或类型。这两个阶段不能混用。
用数组引用保留长度
内建数组传给按值形参时会退化为指针，指针不携带元素个数。把形参写成数组引用，长度 N 就能参与推导：
cpp
#include <cstddef>
#include <iostream>
template<typename T, std::size_t N>
constexpr std::size_t extent_of(const T (&)[N]) noexcept {
return N;
}
template<typename T, std::size_t N>
T sum_array(
输出：
text
4 77
3 6.75extent_of 只要求实参是数组。sum_array 的要求更多：T{} 必须有效，total += value 也必须有效。这说明相同的参数形式不代表相同的类型要求，函数体同样属于接口契约的一部分。
默认模板实参提供常用配置
类模板也能给参数默认值：
cpp
template<typename T, std::size_t Capacity = 8>
class SmallBuffer;
SmallBuffer<int> common; // 等价于 SmallBuffer<int, 8>
SmallBuffer<int, 32> larger; // 覆盖默认容量默认模板实参只是在调用者省略模板实参时补值。它不会把 SmallBuffer<int, 8> 和 SmallBuffer<int, 32> 合并成同一个类型。
默认函数实参与默认模板实参也要分开看：
cpp
template<typename T>
T make_value(T value = T{}) {
return value;
}
// auto a = make_value(); // 错误：省略的函数实参不能提供 T 的推导信息
auto b = make_value<int>(); // 正确：显式指定 T推导只使用实际存在的函数实参与形参模式。函数参数有默认值，并不意味着编译器会先执行默认表达式再反推 T。
小节测试
2.1
下列哪些值可以直接用作固定容量的非类型模板实参？
2.2
在形参 `const T (&values)[N]` 中，负责保留并推导数组长度的模板参数是 ____。
类模板与成员模板
类模板形成一族不同的类型
下面实现一个固定容量的小缓冲区。它同时使用元素类型 T 和容量 Capacity：
cpp
#include <array>
#include <cstddef>
#include <stdexcept>
#include <type_traits>
template<typename T, std::size_t Capacity = 4>
class SmallBuffer {
static_assert(Capacity > 0, "Capacity must be positive");
static_assert(std::is_default_constructible_v<T>, "T must be default constructible");
static_assert
SmallBuffer<int, 3> 是一个具体类型，SmallBuffer<double, 3> 是另一个具体类型。二者来自同一模板，但不能因此直接互相赋值。
公开 value_type 和 size_type 是一种接口约定。调用者可以按成员类型的角色写代码，不需要猜测实现到底用了哪种整数类型。
在类外定义成员
类模板成员写在类体外时，需要再次声明模板参数，并用完整模板标识限定类名：
cpp
template<typename T, std::size_t Capacity>
void SmallBuffer<T, Capacity>::push(const T& value) {
if (size_ == Capacity) {
throw std::length_error("SmallBuffer is full");
}
data_[size_] = value;
++size_;
}
类体内可以直接写 SmallBuffer 表示当前实例类型；类体外必须写 SmallBuffer<T, Capacity>，因为定义要说明自己属于哪一族实例。
成员模板有两层参数
copy_from 不只依赖类自己的 T 和 Capacity，还要接收源数组的元素类型 U 与长度 N。类外定义时要连续写两层模板参数列表：
cpp
template<typename T, std::size_t Capacity>
template<typename U, std::size_t N>
void SmallBuffer<T, Capacity>::copy_from(const U (&source)[N]) {
static_assert(std::is_convertible_v<U, T>, "source element must convert to T");
size_
第一层属于类模板，第二层属于成员函数模板。这个成员让一个具体的 SmallBuffer<int, 3> 接收不同源数组类型，但目标缓冲区本身仍然是原来的具体类型。
完整调用如下：
cpp
#include <iostream>
int main() {
const double source[] = {2.5, 4.0, 6.75, 8.0};
SmallBuffer<int, 3> values;
values.copy_from(source);
std::cout << "size=" << values.size()
<< " capacity=" << values.capacity() << '
输出：
text
size=3 capacity=3
2 4 6显式 static_cast<T> 把数值转换写在接口实现中，避免悄悄依赖隐式窄化。容量只允许三个元素，因此第四个源元素不会被复制。
T, Capacity 与成员模板参数 U, N 分属不同模板作用域。从具体版本再泛化
类模板一开始就写得很复杂，错误会混在模板诊断里。更稳妥的开发顺序是先做一个 int、固定容量的版本，验证边界和状态变化，再把元素类型与容量替换成模板参数。
泛化后要重新检查具体版本里的假设。本例的 data_{} 要求 T 可默认构造，赋值存入又要求 T 可复制赋值。这些要求不是模板语法自动产生的，而是当前存储方案产生的。若接口要接纳不可默认构造类型，就需要改用未初始化存储和显式构造，而不是删除提示后假装限制不存在。
类模板的每个具体实例都是独立类型。某两个元素类型存在继承或转换关系，也不会自动把两个容器实例变成继承关系。
小节测试
3.1
`SmallBuffer<int, 4>` 可以直接绑定到 `SmallBuffer<int, 8>&`，因为它们来自同一个类模板。
3.2
类外定义成员模板 `copy_from` 时，为什么需要两条 template 声明？
模板实参推导与显式实参
按值与按引用会保留不同信息
函数模板推导先把函数实参类型与形参模式对照。形参是按值的 T 时，顶层 const 被忽略，数组和函数会退化为指针：
cpp
template<typename T>
void inspect_value(T value);
const int answer = 42;
int numbers[3] = {1, 2, 3};
inspect_value(answer); // T 为 int
inspect_value(numbers); // T 为 int*形参是引用时会保留更多信息：
cpp
template<typename T>
void inspect_ref(T& value);
inspect_ref(answer); // T 为 const int
inspect_ref(numbers); // T 为 int[3]const T& 又是另一种模式。它允许绑定到只读对象和临时值，模板参数 T 通常不包含形参模式已经写出的那层 const。
选择形参形式不只是性能问题。它会决定推导保留哪些类型信息，也会决定调用者能传什么对象。
同一个参数不能推导出两个冲突类型
下面的模板用同一个 T 描述两个形参：
cpp
template<typename T>
bool same_type(T lhs, T rhs) {
return lhs == rhs;
}
same_type(1, 2); // T 为 int
// same_type(1, 2.0); // 错误：一个位置推出 int，另一个位置推出 double推导阶段不会先把 int 转成 double，再宣布两者类型相同。若设计确实希望以 double 处理，可以显式指定模板实参：
cpp
const bool equal = same_type<double>(1, 2.0);此时 T 已确定为 double，调用的是具体函数 same_type<double>(double, double)；整数 1 随后按普通函数调用规则转换为 double。
另一种设计是使用两个类型参数：
cpp
template<typename L, typename R>
bool equal_after_conversion(const L& lhs, const R& rhs) {
return lhs == rhs;
}这会扩大接口承诺：现在要求 L 与 R 能直接进行 ==。是否该放宽，取决于业务含义，不能只为了让某次调用通过。
返回位置不参与推导
模板参数只出现在返回类型中时，编译器无法从赋值左侧反推：
cpp
template<typename Result, typename A, typename B>
Result add_as(A lhs, B rhs) {
return static_cast<Result>(lhs + rhs);
}
const auto total = add_as<long long>(10, 20);这里显式给出第一个模板实参 Result，后面的 A 与 B 仍从函数实参推导。把不能推导的参数放在模板参数列表前面，调用者就可以只写必要的前缀。
下面的写法则不能工作：
cpp
template<typename T>
T zero() {
return T{};
}
// long value = zero(); // 错误：赋值目标 long 不参与 T 的推导
long value = zero<long>();诊断推导错误的顺序
看到“没有匹配函数”时，先不要钻进长长的实例化轨迹。按下面顺序检查：
- 每个模板参数从哪些函数形参位置获得信息？
- 同一参数是否从不同位置得到冲突类型？
- 数组是否因按值形参退化成了指针？
- 是否有模板参数只出现在返回类型或其他不可推导位置？
- 显式指定部分模板实参后，剩余实参是否还能正常推导？
小节测试
4.1
调用 `same_type(1, 2.0)` 失败的直接原因是什么？
4.2
关于函数模板推导，下列哪些说法正确？
依赖名字与 typename
编译器暂时不知道成员名是什么
模板中有些名字依赖模板参数。例如容器常把元素类型命名为 value_type：
cpp
template<typename Container>
typename Container::value_type last_value(const Container& container) {
return container.back();
}在 Container 尚未替换成具体类型时，Container::value_type 可能是类型，也可能是静态数据成员。语法解析必须先继续，因此 C++ 默认把这类依赖限定名按非类型理解。typename 明确告诉编译器：这里需要把它解析成类型。
这和模板参数列表中的 typename Container 是两个用途：
template<typename Container>声明一个类型模板参数。typename Container::value_type给依赖成员名消歧。
省略第二处 typename，常会看到“需要 typename”或“依赖名称不是类型”一类诊断。修复时不要到处添加关键字，只在语法位置确实需要一个依赖类型时添加。
用别名缩短依赖类型
可以把常用依赖类型封装为别名模板：
cpp
template<typename Container>
using element_t = typename Container::value_type;
template<typename Container>
element_t<Container> first_value(const Container& container) {
return container.front();
}element_t<Container> 不仅更短，还把“如何取得元素类型”集中在一个位置。别名不会创造新类型，它只是给已有类型提供另一个名称。
依赖成员模板需要 template 消歧
类似问题也会出现在依赖对象的成员模板调用中：
cpp
#include <iostream>
struct Factory {
template<typename T>
T make() const {
return T{42};
}
};
template<typename FactoryType>
auto build_int(const FactoryType& factory) {
return factory.template make<int>();
}
输出：
text
42factory 的类型依赖 FactoryType，解析器暂时不能确认 make 是成员模板。点号后的 template 明确后面的尖括号是模板实参列表，不是小于运算。
typename 将依赖名标记为类型，.template 将依赖成员标记为成员模板。依赖名字的难点来自解析时机：模板第一次被读取时还不知道具体实参。
typename 和依赖调用处的 template 都是在告诉解析器“稍后按哪一类名字继续检查”。小节测试
5.1
在 `____ Container::value_type value;` 中，应填入哪个关键字来声明依赖成员类型？
5.2
模板参数列表中的 `typename T` 与 `typename T::value_type` 中的 typename 完全承担同一个语法任务。
重载、全特化与偏特化
普通函数与函数模板一起参加选择
函数模板可以与普通函数、其他函数模板同名。编译器先组成候选集，再比较匹配质量与模板的专门程度：
cpp
#include <iostream>
#include <string>
template<typename T>
std::string describe(const T&) {
return "value template";
}
template<typename T>
std::string describe(T*) {
return "pointer template";
}
std::
输出：
text
value template
pointer template
string overload整数只能进入通用模板。指针同时能匹配通用引用模板和指针模板，T* 版本只描述指针形状，因此更专门。字符串的普通函数与通用模板都能精确匹配；匹配同样好时，普通非模板函数胜出。
“普通函数优先”不是无条件规则。如果普通函数需要转换，而模板能精确匹配，模板仍可能胜出。先比较转换质量，只有打平时才使用后续规则。
类模板可以全特化
全特化为一组完整模板实参提供单独实现：
cpp
#include <string_view>
template<typename T>
struct shape_of {
static constexpr std::string_view name = "ordinary";
};
template<>
struct shape_of<bool> {
static constexpr std::string_view name = "boolean";
};shape_of<bool> 不再保留未确定模板参数，它只处理一个完整具体类型，所以是全特化。全特化必须以已有主模板为基础。
类模板可以偏特化
偏特化仍然保留参数，但限制模板实参的形状：
cpp
#include <cstddef>
template<typename T>
struct shape_of<T*> {
static constexpr std::string_view name = "pointer";
};
template<typename T, std::size_t N>
struct shape_of<T[N]> {
static constexpr std::string_view name
shape_of<int*> 进入指针偏特化，shape_of<double[5]> 进入数组偏特化。T 或 T,N 仍由具体实参推导，因此这些定义本身还是模板。
可运行检查：
cpp
#include <iostream>
#include <string_view>
int main() {
std::cout << shape_of<int>::name << '\n';
std::cout << shape_of<int*>::name << '\n';
std::cout << shape_of<bool>::name << '\n';
输出：
text
ordinary
pointer
boolean
array 5函数模板不能偏特化
下面这种“给所有指针写函数偏特化”的语法不成立：
cpp
template<typename T>
void inspect(const T& value);
// 错误：函数模板不能偏特化
// template<typename T>
// void inspect<T*>(T* value);函数调用已经有重载机制，正确做法是新增模板重载：
cpp
template<typename T>
void inspect(T* value);函数模板可以显式全特化，但处理特殊调用形状时，重载通常更直接：它会作为独立候选参加函数选择。显式特化更适合“主模板已经被选中，只为一组完整实参替换实现”的情况。
可以用下面的判断顺序避免混淆：
- 需要改变函数候选和匹配规则：写重载。
- 类模板要处理某个完整类型：考虑全特化。
- 类模板要处理一类形状，如指针或数组：考虑偏特化。
- 普通接口能通过策略参数表达差异：先考虑策略，减少散落的特化。
特化不是给主模板随意打补丁。它必须与主模板处在正确的命名空间，并在可能触发相应隐式实例化之前可见。若函数选择本身需要变化，优先用重载表达意图。
小节测试
6.1
`describe(pointer)` 为什么选择 `describe(T*)`？
6.2
下列哪些 C++17 模板机制合法？
6.3
只要存在普通函数重载，调用时就一定不会选择函数模板。
可变参数模板与折叠表达式
参数包表示零个或多个参数
固定模板参数一个名字对应一个实参。可变参数模板用参数包接收任意数量的类型：
cpp
template<typename... Types>
struct TypeList {};
TypeList<> empty;
TypeList<int> one;
TypeList<int, double, const char*> three;Types 是类型模板参数包。它不是运行时数组，不能用下标访问。编译器会在允许的语法位置展开整包。
函数模板可以同时声明类型包和函数参数包：
cpp
#include <cstddef>
template<typename... Args>
constexpr std::size_t argument_count(const Args&...) noexcept {
return sizeof...(Args);
}
static_assert(argument_count() == 0);
static_assert(argument_count(1, 2.0, 'x') == 3sizeof...(Args) 给出类型包大小，若参数包命名为 args，sizeof...(args) 给出函数参数包大小。二者在这里相同，结果都是编译期常量。
折叠表达式把操作作用到整包
C++17 可用折叠表达式展开常见的重复二元操作：
cpp
#include <iostream>
#include <string>
template<typename... Args>
void print_line(const Args&... args) {
std::cout << "count=" << sizeof...(Args) << ':';
((std::cout << ' ' << args), ...);
std::cout << '\n';
输出：
text
count=0:
count=4: 1 two 3.5 1
10
6.5((std::cout << ' ' << args), ...) 对每个实参生成一次输出表达式，再用逗号运算连接。逗号折叠按顺序完成这些副作用。
(init + ... + args) 是带初值的二元左折叠。三个参数时可理解为：
cpp
(((init + arg1) + arg2) + arg3)没有附加参数时，结果就是 init，所以 sum_from(10) 合法。
方向会改变非结合运算的结果
折叠有四种形式：
- 一元左折叠：
(... op pack)。 - 一元右折叠：
(pack op ...)。 - 二元左折叠：
(init op ... op pack)。 - 二元右折叠：
(pack op ... op init)。
对加法这类常见数值操作，左右结合在理想数学模型里可能相同，但浮点舍入仍可能使结果有差异。对减法，方向会明显改变结果：
cpp
template<typename... Args>
constexpr auto subtract_left(Args... args) {
return (0 - ... - args);
}
template<typename... Args>
constexpr auto subtract_right(Args... args) {
return (args - ... - 0);
空包需要明确身份值
不是所有一元折叠都能处理空包。语言只为少数运算规定空包身份，例如逻辑与的 true、逻辑或的 false 和逗号表达式的空结果。
需要支持零个参数时，带显式初值的二元折叠通常更清楚。初值同时决定一部分类型行为，例如 0 + ... 会先引入 int；若接口要保留精确数值类型，应认真选择初值或要求至少一个实参。
参数包只解决“参数数量可变”，不会减少操作要求。输出折叠要求每个实参都能写入目标流；加法折叠要求每一步相加都合法。
Types... 是在编译期展开的参数包；减法的二元左折叠得到 -6，二元右折叠得到 2。模板错误可按推导、替换与候选移除、函数体实例化三个阶段定位。小节测试
7.1
表达式 `sizeof...(Args)` 得到模板参数包 Args 的 ____。
7.2
`(0 - ... - args)` 属于哪种折叠？
7.3
模板参数包本质上是一个运行时容器，可以用普通 for 循环和下标遍历。
泛型接口检查与错误诊断
把语法要求放到接口附近
C++17 没有语言级 requires 子句，但可以用类型特征检查一部分表达式要求。下面探测比较器能否接收两个 const T&，并把结果转成 bool：
cpp
#include <functional>
#include <type_traits>
#include <utility>
template<typename T, typename Compare, typename = void>
struct can_compare : std::false_type {};
template<typename T, typename Compare>
using compare_result_t = decltype(std::declval<Compare&>()(
std::declval 只用于未求值语境，帮助构造“如果有这种对象，表达式能否成立”的类型问题。std::void_t 在表达式合法时得到 void，从而选择第二个偏特化；表达式不合法时，探测失败，保留主模板的 false。
把检查接到比较函数入口：
cpp
template<typename T, typename Compare = std::less<T>>
int checked_compare(const T& lhs, const T& rhs, Compare comp = Compare{}) {
static_assert(can_compare<T, Compare>::value, "Compare must accept two const T& values");
if constexpr (can_compare
if constexpr 让探测失败时不再实例化不可调用分支，诊断会更靠近 static_assert。下面的比较器没有调用运算符，因此会在接口检查处失败：
cpp
struct NotCallable {};
// checked_compare(1, 2, NotCallable{});
// 编译失败：Compare 不能接收两个 const int&语法检查不能证明语义
类型特征只能判断表达式能否形成。它不能证明比较器满足传递性，也不能判断两个相等值是否会同时被判为更小：
cpp
struct AlwaysTrue {
bool operator()(int, int) const noexcept {
return true;
}
};
static_assert(can_compare<int, AlwaysTrue>::value);AlwaysTrue 通过语法检查，却不是可用的严格次序关系。泛型接口的完整要求通常有两部分：
- 语法要求：表达式存在，返回类型可用，对象能按接口需要复制或移动。
- 语义要求：操作含义稳定，比较关系满足约定，不变量和生命周期得到保持。
前者可以部分交给编译器，后者仍要靠清楚的接口描述、代表性测试和代码审查。
从实例化轨迹中找到第一处实质错误
模板诊断可能列出多层调用。阅读时抓住两个位置：
- 最外层实例化点：哪一行调用给出了什么具体类型？
- 最内层失败表达式：把
T手动换成该类型后，哪个操作不存在或返回类型不对？
例如 sum_array(NoAdd[3]) 的关键不是模板名字有多长，而是 NoAdd total{} 是否成立、total += value 是否成立。逐项还原类型要求，通常比从最后一行诊断反向猜测更快。
常见失败可分成三类：
- 推导失败：还没形成具体函数，例如同一个
T推导冲突。 - 替换或候选失败：某个依赖类型或表达式无法形成，候选被移除。
- 实例化函数体失败：候选已经选中，但具体类型不支持函数体中的操作。
区分阶段能避免错误修复。推导冲突不该靠在函数体里加分支处理；缺少 typename 也不是给类型补运算符能解决的。
泛化时的实践流程
先用一个具体类型完成逻辑并测试边界，确认错误不来自普通控制流程。
标出真正变化的类型、编译期值和策略，把它们提升为模板参数，不要顺手把所有实现细节都参数化。
列出模板体实际使用的操作，删除不必要的要求。例如三路比较保留同一个小于关系即可。
用差异明显的实参测试：内建数值、字符串、自定义类型、不可默认构造类型，以及预期应失败的类型。
交付前检查表
- 模板参数是否都有明确角色，名称是否表达元素、容量或策略？
- 同一个模板参数是否被不必要地用于多个必须同型的位置？
- 按值形参是否意外丢失数组长度或顶层限定？
- 模板定义在所有隐式实例化点是否可见？
typename与依赖成员调用的template是否写在需要的位置？- 函数的特殊调用是否应写重载，而不是误写偏特化？
- 类模板偏特化是否确实表达一类稳定的类型形状？
- 参数包是否定义了空包行为，折叠方向是否符合运算含义？
- 静态检查覆盖了哪些语法要求，还有哪些语义只能靠测试保证？
做到这些，模板代码就不再是一串靠试错拼出的尖括号。它会成为一份清楚的编译期接口：变化点由参数表达，必要操作由实现和检查表达，错误能沿着推导与实例化路径定位。
小节测试
8.1
C++17 类型特征适合直接检查哪些内容？
8.2
模板诊断很长时，最先应该对应哪两处信息？
8.3
只要 `can_compare` 为 true，就已经证明比较器满足严格次序关系的全部语义。