c++ template second

【实例简介】

本书第一版大约出版于 15 年前。起初我们的目的是编写一本对 C 工程师有帮 助的 C 模板权威指南。目前该项目从以下几个方面来看是成功的：它的作用得 到了不少读者的认可，也多次被推荐为参考书目，并屡获好评。 第一版已经很老了，虽然其中不少内容对 modern C 工程师依然很有帮助，但 是鉴于 C 近年来的不断发展，比如 modern C 中从 C 11 到 C 14，再到 C 17 标准的制定，对第一版中部分内容的修订势在必行。 对于第二版，我们的宗旨依然没有变：提供 C 模板的权威指南，它既应该是一 本内容全面的参考书，也应是一本容易理解的教程。只是这一次我们针对的是 modern C ，它要远远复杂于本书第一版出版时的那个 C 。 目前的 C 编程环境要好于本书第一版发布之时。比如这期间出现了一些深入探 讨模板应用的书籍。更重要的是，我们可以从互联网上获取更多的 C 模板知识， 以及基于模板的编程技术和应用实例。因此在这一版中，我们将重点关注那些可 以被广泛应用的技术。 第一版中的部分内容目前来看已经过时了，因为 modern C 提供了可以完成相 同功能，但又颇为简单的方法。因此这一部分内容会被从第二版中删除，不过不 用担心，modern C 中对应的更为先进的内容会被加入进来。 尽管 C 模板的概念已经出现了 20 多年了，目前 C 开发者社区中依然会不断发 现其在软件开发中新的应用场景。本书的目标之一是和读者分享这些内容，当然 也希望能够启发读者产生新的理解和发现。

【实例截图】C 模板_第二版.pdf

【核心代码】

目录
目录
C   模板（第二版）.........................................................................................................................1
关于本书............................................................................................................................................. 2
阅读本书前应该具备哪些知识？.....................................................................................................2
如何阅读本书.....................................................................................................................................3
C  11，14 和 17 标准........................................................................................................................3
目录..................................................................................................................................................... 5
第一部分............................................................................................................................................. 1
基础知识.....................................................................................................................................1
为什么要使用模板？.................................................................................................................1
第 1 章 函数模板（Function Templates）.......................................................................................3
1.1 函数模板初探......................................................................................................................3
1.1.1 定义模板...................................................................................................................3
1.1.2 使用模板...................................................................................................................4
1.1.3 两阶段编译检查（Two-Phase Translation ）........................................................5
1.1.4 编译和链接................................................................................................................6
1.2 模板参数推断......................................................................................................................6
类型推断中的类型转换.....................................................................................................7
对默认调用参数的类型推断.............................................................................................8
1.3 多个模板参数......................................................................................................................8
1.3.1 作为返回类型的模板参数...................................................................................... 9
1.3.2 返回类型推断 .......................................................................................................10
1.3.3 将返回类型声明为公共类型（Common Type）.................................................11
1.4 默认模板参数....................................................................................................................12
1.5 函数模板的重载................................................................................................................13
1.6 难道，我们不应该...？.....................................................................................................17
1.6.1 按值传递还是按引用传递？................................................................................ 18
1.6.2 为什么不适用 inline？.......................................................................................... 18
1.6.3 为什么不用 constexpr？........................................................................................18
1.7 总结....................................................................................................................................19
第 2 章 类模板（Class Templates）............................................................................................... 20
2.1 Stack 类模板的实现........................................................................................................... 20
2.1.1 声明一个类模板.....................................................................................................21
2.1.2 成员函数的实现.....................................................................................................22
2.2 Stack 类模板的使用........................................................................................................... 23
2.3 部分地使用类模板............................................................................................................25
2.3.1 Concept（最好不要汉化这一概念）....................................................................26
2.4 友元....................................................................................................................................26
2.5 模板类的特例化................................................................................................................28
2.6 部分特例化........................................................................................................................29
五车书馆
多模板参数的部分特例化...............................................................................................30
2.7 默认类模板参数................................................................................................................31
2.8 类型别名（Type Aliases）................................................................................................33
Typedefs 和 Alias 声明....................................................................................................33
Alias Templates（别名模板）......................................................................................... 34
Alias Templates for Member Types（class 成员的别名模板）......................................34
Type Traits Suffix_t （Suffix_t 类型萃取）.................................................................... 35
2.9 类模板的类型推导............................................................................................................35
类模板对字符串常量参数的类型推断（Class Template Arguments Deduction with
String Literals ）...............................................................................................................36
推断指引（Deduction Guides）......................................................................................38
2.10 聚合类的模板化（Templatized Aggregates）...............................................................39
2.11 总结..................................................................................................................................39
第 3 章 非类型模板参数.................................................................................................................41
3.1 类模板的非类型参数........................................................................................................41
3.2 函数模板的非类型参数....................................................................................................43
3.3 非类型模板参数的限制....................................................................................................44
避免无效表达式...............................................................................................................45
3.4 用 auto 作为非模板类型参数的类型..............................................................................46
3.4 总结....................................................................................................................................49
第 4 章 变参模板.............................................................................................................................50
4.1 变参模板............................................................................................................................50
4.1.1 变参模板实列.........................................................................................................50
4.1.2 变参和非变参模板的重载.................................................................................... 51
4.1.3 sizeof... 运算符........................................................................................................52
4.2 折叠表达式........................................................................................................................53
4.3 变参模板的使用................................................................................................................55
4.4 变参类模板和变参表达式................................................................................................56
4.4.1 变参表达式.............................................................................................................56
4.4.2 变参下标（Variadic Indices）............................................................................... 57
4.4.3 变参类模板.............................................................................................................58
4.4.4 变参推断指引.........................................................................................................59
4.4.5 变参基类及其使用................................................................................................ 59
4.5 总结....................................................................................................................................61
第 5 章 基础技巧.............................................................................................................................62
5.1 typename 关键字............................................................................................................... 62
5.2 零初始化............................................................................................................................63
5.3 使用 this->..........................................................................................................................65
5.4 使用裸数组或者字符串常量的模板............................................................................... 65
5.5 成员模板............................................................................................................................68
成员模板的特例化...........................................................................................................72
特殊成员函数的模板.......................................................................................................73
5.5.1 .template 的使用..................................................................................................... 73
5.5.2 泛型 lambdas 和成员模板.....................................................................................74
五车书馆
5.6 变量模板............................................................................................................................74
用于数据成员的变量模板...............................................................................................76
类型萃取 Suffix_v.............................................................................................................77
5.7 模板参数模板....................................................................................................................77
模板参数模板的参数匹配...............................................................................................79
5.8 总结....................................................................................................................................82
第 6 章 移动语义和 enable_if<>.................................................................................................... 83
6.1 完美转发（Perfect Forwarding）.....................................................................................83
6.2 特殊成员函数模板............................................................................................................86
6.3 通过 std::enable_if<>禁用模板........................................................................................ 89
6.4 使用 enable_if<>................................................................................................................90
禁用某些成员函数...........................................................................................................92
6.5 使用 concept 简化 enable_if<>表达式............................................................................ 94
6.6 总结....................................................................................................................................95
第 7 章 按值传递还是按引用传递？.............................................................................................96
7.1 按值传递............................................................................................................................96
按值传递会导致类型退化（decay）.............................................................................98
7.2 按引用传递........................................................................................................................98
7.2.1 按 const 引用传递..................................................................................................98
7.2.2 按非 const 引用传递............................................................................................100
7.2.3 按转发引用传递参数（Forwarding Reference）.............................................. 102
7.3 使用 std::ref()和 std::cref() （限于模板）..................................................................103
7.4 处理字符串常量和裸数组............................................................................................. 105
7.4.1 关于字符串常量和裸数组的特殊实现.............................................................. 106
7.5 处理返回值......................................................................................................................107
7.6 关于模板参数声明的推荐方法..................................................................................... 108 一般性建议.....................................................................................................................108
不要过分泛型化.............................................................................................................109
以 std::make_pair<>为例............................................................................................... 109
7.7 总结..................................................................................................................................110
第 8 章 编译期编程.......................................................................................................................112
8.1 模板元编程......................................................................................................................112
8.2 通过 constexpr 进行计算................................................................................................114
8.3 通过部分特例化进行路径选择..................................................................................... 115
8.4 SFINAE (Substitution Failure Is Not An Error, 替换失败不是错误)................................ 117
SFINAE and Overload Resolution....................................................................................119
8.4.1 通过 decltype 进行 SFINAE（此处是动词）的表达式..................................... 120
8.5 编译期 if...........................................................................................................................121
8.6 总结..................................................................................................................................123
第 9 章 在实践中使用模板...........................................................................................................124
9.1 包含模式..........................................................................................................................124
9.1.1 链接错误...............................................................................................................124
9.1.2 头文件中的模板.................................................................................................. 125
9.2 模板和 inline....................................................................................................................126
五车书馆
9.3 预编译头文件..................................................................................................................127
9.4 破译大篇幅的错误信息..................................................................................................129
简单的类型不匹配情况.................................................................................................129
9.5 后记..................................................................................................................................137
9.6 总结..................................................................................................................................138
第 10 章 模板基本术语.................................................................................................................139
10.1 “类模板”还是“模板类”....................................................................................... 139
10.2 替换，实例化，和特例化........................................................................................... 139
10.3 声明和定义....................................................................................................................140
10.3.1 完整类型和非完整类型（complete versus incomplete types）.................... 141
10.4 唯一定义法则................................................................................................................142
10.5 Template Arguments versus Template Parameters........................................................ 142
10.6 总结................................................................................................................................143
第 11 章 泛型库.............................................................................................................................145
11.1 可调用对象（Callables）............................................................................................. 145
11.1.1 函数对象的支持................................................................................................ 146
11.1.2 处理成员函数以及额外的参数........................................................................ 147
11.1.3 函数调用的包装................................................................................................ 149
11.2 其他一些实现泛型库的工具....................................................................................... 151
11.2.1 类型萃取.............................................................................................................151
11.2.2 std::addressoff()...................................................................................................153
11.2.3 std::declval().........................................................................................................153
11.3 完美转发临时变量........................................................................................................154
11.4 作为模板参数的引用....................................................................................................154
11.5 推迟计算（Defer Evaluation）.....................................................................................158
11.6 在写泛型库时需要考虑的事情................................................................................... 159
11.7 总结................................................................................................................................160
第 18 章 模板的多态性.................................................................................................................161
18.1 动态多态（dynamic polymorphism）......................................................................... 161
18.2 静态多态........................................................................................................................163
18.3 动态多态 VS 静态多态............................................................................................... 166
术语.................................................................................................................................166
优点和缺点.....................................................................................................................167
结合两种多态形式.........................................................................................................167
18.4 使用 concepts................................................................................................................ 168
18.5 新形势的设计模式........................................................................................................169
18.6 泛型编程（Generic Programming）............................................................................170
18.7 后记................................................................................................................................173
第 19 章 萃取的实现.....................................................................................................................174
19.1 一个例子：对一个序列求和....................................................................................... 174
19.1.1 固定的萃取（Fixed Traits）.............................................................................. 174
19.1.2 值萃取（Value Traits）......................................................................................177
19.1.3 参数化的萃取.................................................................................................... 181
19.2 萃取还是策略以及策略类（Traits versus Policies and Policies Classes）................. 182
五车书馆
19.2.1 萃取和策略：有什么区别？（Traits and Policies: What’s the Difference?）184
19.2.2 成员模板还是模板模板参数？（Member Templates versus Template Template
Parameters）.................................................................................................................. 185
19.2.3 结合多个策略以及/或者萃取（Combining Multiple Policies and/or Traits）186
19.2.4 通过普通迭代器实现累积（Accumulation with General Iterators）.............186
19.3 类型函数（Type Function）.........................................................................................187
19.3.1 元素类型（Element Type）............................................................................... 188
19.3.2 转换萃取（Transformation Traits）..................................................................190
19.3.3 预测型萃取（Predicate Traits）....................................................................... 196
19.3.4 返回结果类型萃取（Result Type Traits）........................................................199
19.4 基于 SFINAE 的萃取（SFINAE-Based Traits）............................................................. 201
10.4.1 用 SFINAE 排除某些重载函数...........................................................................201
19.4.2 用 SFINAE 排除偏特化.......................................................................................205
19.4.3 将泛型 Lambdas 用于 SFINAE（Using Generic Lambdas for SFINAE）...........207
19.4.4 SFINAE 友好的萃取.............................................................................................209
19.5 IsConvertibleT..................................................................................................................213
19.6 探测成员（Detecting Members）............................................................................... 215
19.6.1 探测类型成员（Detecting Member Types）................................................... 215
19.6.2 探测任意类型成员............................................................................................ 217
19.6.3 探测非类型成员................................................................................................ 218
19.6.4 用泛型 Lambda 探测成员................................................................................. 222
19.7 其它的萃取技术............................................................................................................224
19.7.1 If-Then-Else.......................................................................................................... 224
19.7.2 探测不抛出异常的操作.................................................................................... 227
19.7.3 萃取的便捷性（Traits Convenience）..............................................................229
19.8 类型分类（Type Classification）..................................................................................231
19.8.1 判断基础类型（Determining Fundamental Types）....................................... 232
19.8.2 判断复合类型.................................................................................................... 234
19.8.3 识别函数类型（Identifying Function Types）................................................. 237
19.8.4 判断 class 类型（Determining Class Types）...................................................239
19.8.5 识别枚举类型（Determining Enumeration Types）........................................239
19.9 策略萃取（Policy Traits）............................................................................................ 240
19.9.1 只读参数类型.................................................................................................... 240
19.10 在标准库中的情况..................................................................................................... 243
19.11 后记..............................................................................................................................244
第 20 章 基于类型属性的重载（Overloading on Type Properties）.........................................245
20.1 算法特化（我更愿意称之为算法重载，见注释）................................................... 245
20.2 标记派发（Tag Dispatching）...................................................................................... 247
20.3 Enable/Disable 函数模板............................................................................................... 248
20.3.1 提供多种特化版本............................................................................................ 250
20.3.2 EnableIf 所之何处（where does the EnableIf Go）?........................................251
20.3.3 编译期 if............................................................................................................. 253
20.3.4 Concepts...............................................................................................................254
20.4 类的特化（Class Specialization）................................................................................ 255
五车书馆
20.4.1 启用/禁用类模板...............................................................................................256
20.4.2 类模板的标记派发............................................................................................ 257
20.5 实例化安全的模板（Instantiation-Safe Templates）................................................. 260
20.6 在标准库中的情况........................................................................................................265
20.7 后记................................................................................................................................265
第 21 章 模板和继承.....................................................................................................................267
21.1 空基类优化（The Empty Class Optimization，EBCO）..............................................267
21.1.1 布局原则.............................................................................................................267
21.1.2 将数据成员实现为基类.................................................................................... 270
21.2 The Curiously Recurring Template Pattern (CRTP)......................................................... 272
21.2.1 The Barton-Nackman Trick...................................................................................274
21.2.2 运算符的实现（Operator Implementations）.................................................277
21.2.3 Facades.................................................................................................................278
21.3 Mixins（混合？）.......................................................................................................... 284
21.3.1 Curious Mixins......................................................................................................287
21.3.2 Parameterized Virtuality（虚拟性的参数化）..................................................287
21.4 Named Template Arguments（命名的模板参数）......................................................288
21.5 后记................................................................................................................................291
第 22 章 桥接 static 和 dynamic 多态.......................................................................................... 293
22.1 函数对象，指针，以及 std:function<>.......................................................................293
22.2 广义函数指针................................................................................................................295
22.3 桥接接口（Bridge Interface）......................................................................................297
22.4 类型擦除（Type Erasure）...........................................................................................298
22.5 可选桥接（Optional Bridging）...................................................................................299
22.6 性能考量........................................................................................................................302
22.7 后记................................................................................................................................302
第 23 章 元编程.............................................................................................................................303
23.1 现代 C  元编程的现状................................................................................................ 303
2.3.1.1 值元编程（Value Metaprogramming）...........................................................303
23.1.2 类型元编程.........................................................................................................304
23.1.3 混合元编程.........................................................................................................305
23.1.4 将混合元编程用于“单位类型”（Units Types，可能翻译的不恰当）.....307
23.2 反射元编程的维度........................................................................................................310
23.3 递归实例化的代价........................................................................................................311
23.3.1 追踪所有的实例化过程.................................................................................... 313
23.4 计算完整性....................................................................................................................314
23.5 递归实例化和递归模板参数....................................................................................... 314
23.6 枚举值还是静态常量....................................................................................................315
23.7 后记................................................................................................................................316
第 24 章 类型列表（Typelists）..................................................................................................320
24.1 类型列表剖析（Anatomy of a Typelist）.................................................................... 320
24.2 类型列表的算法............................................................................................................322
24.2.1 索引（Indexing）...............................................................................................322
24.2.2 寻找最佳匹配.................................................................................................... 323
五车书馆
24.2.3 向类型类表中追加元素.................................................................................... 325
24.2.4 类型列表的反转................................................................................................ 327
24.2.5 类型列表的转换................................................................................................ 328
24.2.6 类型列表的累加（Accumulating Typelists）................................................... 329
24.2.7 插入排序.............................................................................................................331
24.3 非类型类型列表（Nontype Typelists）...................................................................... 334
24.3.1 可推断的非类型参数........................................................................................ 336
24.4 对包扩展相关算法的优化（Optimizing Algorithms with Pack Expansions ）......... 337
24.5 Cons-style Typelists（不完美的类型列表？）.............................................................338
24.6 后记................................................................................................................................340
第 25 章 元组（Tuples）.............................................................................................................. 342
25.1 基本的元组设计............................................................................................................342
25.1.1 存储（Storage）................................................................................................ 342
25.1.2 构造.....................................................................................................................344
25.2 基础元组操作................................................................................................................346
25.2.1 比较.....................................................................................................................346
25.2.2 输出.....................................................................................................................347
25.3 元组的算法....................................................................................................................347
25.3.1 将元组用作类型列表........................................................................................ 348
25.3.2 添加以及删除元素............................................................................................ 349
25.3.3 元组的反转.........................................................................................................350
25.3.4 索引列表.............................................................................................................351
25.3.5 通过索引列表进行反转.................................................................................... 352
25.3.6 洗牌和选择（Shuffle and Select ）................................................................. 354
25.4 元组的展开....................................................................................................................357
25.5 元组的优化....................................................................................................................357
25.5.1 元组和 EBCO.......................................................................................................358
25.5.2 常数时间的 get()................................................................................................362
25.6 元组下标........................................................................................................................363
25.7 后记................................................................................................................................365