极客时间已完结课程限时免费阅读

13 | 编译期能做些什么？一个完整的计算世界

13 | 编译期能做些什么？一个完整的计算世界-极客时间

13 | 编译期能做些什么？一个完整的计算世界

2019-12-25 吴咏炜 来自北京
《现代C++编程实战》
课程介绍

讲述：吴咏炜

时长12:47大小11.68M

你好，我是吴咏炜。
上一讲我们简单介绍了模板的基本用法及其在泛型编程中的应用。这一讲我们来看一下模板的另外一种重要用途——编译期计算，也称作“模板元编程”。

编译期计算

首先，我们给出一个已经被证明的结论：C++ 模板是图灵完全的 [1]。这句话的意思是，使用 C++ 模板，你可以在编译期间模拟一个完整的图灵机，也就是说，可以完成任何的计算任务。
当然，这只是理论上的结论。从实际的角度，我们并不想、也不可能在编译期完成所有的计算，更不用说编译期的编程是很容易让人看不懂的——因为这并不是语言设计的初衷。即便如此，我们也还是需要了解一下模板元编程的基本概念：它仍然有一些实用的场景，并且在实际的工程中你也可能会遇到这样的代码。虽然我们在开篇就说过不要炫技，但使用模板元编程写出的代码仍然是可理解的，尤其是如果你对递归不发怵的话。
好，闲话少叙，我们仍然拿代码说话：
template <int n>
struct factorial {
static const int value =
n * factorial<n - 1>::value;
};
template <>
struct factorial<0> {
static const int value = 1;
};
上面定义了一个递归的阶乘函数。可以看出，它完全符合阶乘的递归定义：
除了顺序有特定的要求——先定义，才能特化——再加语法有点特别，代码基本上就是这个数学定义的简单映射了。
那我们怎么知道这个计算是不是在编译时做的呢？我们可以直接看编译输出。下面直接贴出对上面这样的代码加输出（printf("%d\n", factorial<10>::value);）在 x86-64 下的编译结果：
.LC0:
.string "%d\n"
main:
push rbp
mov rbp, rsp
mov esi, 3628800
mov edi, OFFSET FLAT:.LC0
mov eax, 0
call printf
mov eax, 0
pop rbp
ret
我们可以明确看到，编译结果里明明白白直接出现了常量 3628800。上面那些递归什么的，完全都没有了踪影。
如果我们传递一个负数给 factorial 呢？这时的结果就应该是编译期间的递归溢出。如 GCC 会报告：
fatal error: template instantiation depth exceeds maximum of 900 (use -ftemplate-depth= to increase the maximum)
如果把 int 改成 unsigned，不同的编译器和不同的标准选项会导致不同的结果。有些情况下错误信息完全不变，有些情况下则会报负数不能转换到 unsigned。通用的解决方案是使用 static_assert，确保参数永远不会是负数。
template <int n>
struct factorial {
static_assert(
n >= 0,
"Arg must be non-negative");
static const int value =
n * factorial<n - 1>::value;
};
这样，当 factorial 接收到一个负数作为参数时，就会得到一个干脆的错误信息：
error: static assertion failed: Arg must be non-negative
下面我们看一些更复杂的例子。这些例子不是为了让你真的去写这样的代码，而是帮助你充分理解编译期编程的强大威力。如果这些例子你都完全掌握了，那以后碰到小的模板问题，你一定可以轻松解决，完全不在话下。
回想上面的例子，我们可以看到，要进行编译期编程，最主要的一点，是需要把计算转变成类型推导。比如，下面的模板可以代表条件语句：
template <bool cond,
typename Then,
typename Else>
struct If;
template <typename Then,
typename Else>
struct If<true, Then, Else> {
typedef Then type;
};
template <typename Then,
typename Else>
struct If<false, Then, Else> {
typedef Else type;
};
If 模板有三个参数，第一个是布尔值，后面两个则是代表不同分支计算的类型，这个类型可以是我们上面定义的任何一个模板实例，包括 If 和 factorial。第一个 struct 声明规定了模板的形式，然后我们不提供通用定义，而是提供了两个特化。第一个特化是真的情况，定义结果 type 为 Then 分支；第二个特化是假的情况，定义结果 type 为 Else 分支。
我们一般也需要循环：
template <bool condition,
typename Body>
struct WhileLoop;
template <typename Body>
struct WhileLoop<true, Body> {
typedef typename WhileLoop<
Body::cond_value,
typename Body::next_type>::type
type;
};
template <typename Body>
struct WhileLoop<false, Body> {
typedef
typename Body::res_type type;
};
template <typename Body>
struct While {
typedef typename WhileLoop<
Body::cond_value, Body>::type
type;
};
这个循环的模板定义稍复杂点。首先，我们对循环体类型有一个约定，它必须提供一个静态数据成员，cond_value，及两个子类型定义，res_type 和 next_type：
cond_value 代表循环的条件（真或假）
res_type 代表退出循环时的状态
next_type 代表下面循环执行一次时的状态
这里面比较绕的地方是用类型来代表执行状态。如果之前你没有接触过函数式编程的话，这个在初学时有困难是正常的。把例子多看两遍，自己编译、修改、把玩一下，就会渐渐理解的。
排除这个抽象性，模板的定义和 If 是类似的，虽然我们为方便使用，定义了两个模板。WhileLoop 模板有两个模板参数，同样用特化来决定走递归分支还是退出循环分支。While 模板则只需要循环体一个参数，方便使用。
如果你之前模板用得不多的话，还有一个需要了解的细节，就是用 :: 取一个成员类型、并且 :: 左边有模板参数的话，得额外加上 typename 关键字来标明结果是一个类型。上面循环模板的定义里就出现了多次这样的语法。MSVC 在这方面往往比较宽松，不写 typename 也不会报错，但这是不符合 C++ 标准的用法。
为了进行计算，我们还需要通用的代表数值的类型。下面这个模板可以通用地代表一个整数常数：
template <class T, T v>
struct integral_constant {
static const T value = v;
typedef T value_type;
typedef integral_constant type;
};
integral_constant 模板同时包含了整数的类型和数值，而通过这个类型的 value 成员我们又可以重新取回这个数值。有了这个模板的帮忙，我们就可以进行一些更通用的计算了。下面这个模板展示了如何使用循环模板来完成从 1 加到 n 的计算：
template <int result, int n>
struct SumLoop {
static const bool cond_value =
n != 0;
static const int res_value =
result;
typedef integral_constant<
int, res_value>
res_type;
typedef SumLoop<result + n, n - 1>
next_type;
};
template <int n>
struct Sum {
typedef SumLoop<0, n> type;
};
然后你使用 While<Sum<10>::type>::type::value 就可以得到 1 加到 10 的结果。虽然有点绕，但代码实质就是在编译期间进行了以下的计算：
int result = 0;
while (n != 0) {
result = result + n;
n = n - 1;
}
估计现在你的头已经很晕了。但我保证，这一讲最难的部分已经过去了。实际上，到现在为止，我们讲的东西还没有离开 C++98。而我们下面几讲里很快就会讲到，如何在现代 C++ 里不使用这种麻烦的方式也能达到同样的效果。

编译期类型推导

C++ 标准库在 <type_traits> 头文件里定义了很多工具类模板，用来提取某个类型（type）在某方面的特点（trait）[2]。和上一节给出的例子相似，这些特点既是类型，又是常值。
为了方便地在值和类型之间转换，标准库定义了一些经常需要用到的工具类。上面描述的 integral_constant 就是其中一个（我的定义有所简化）。为了方便使用，针对布尔值有两个额外的类型定义：
typedef std::integral_constant<
bool, true> true_type;
typedef std::integral_constant<
bool, false> false_type;
这两个标准类型 true_type 和 false_type 经常可以在函数重载中见到。有一个工具函数常常会写成下面这个样子：
template <typename T>
class SomeContainer {
public:
…
static void destroy(T* ptr)
{
_destroy(ptr,
is_trivially_destructible<
T>());
}
private:
static void _destroy(T* ptr,
true_type)
{}
static void _destroy(T* ptr,
false_type)
{
ptr->~T();
}
};
类似上面，很多容器类里会有一个 destroy 函数，通过指针来析构某个对象。为了确保最大程度的优化，常用的一个技巧就是用 is_trivially_destructible 模板来判断类是否是可平凡析构的——也就是说，不调用析构函数，不会造成任何资源泄漏问题。模板返回的结果还是一个类，要么是 true_type，要么是 false_type。如果要得到布尔值的话，当然使用 is_trivially_destructible<T>::value 就可以，但此处不需要。我们需要的是，使用 () 调用该类型的构造函数，让编译器根据数值类型来选择合适的重载。这样，在优化编译的情况下，编译器可以把不需要的析构操作彻底全部删除。
像 is_trivially_destructible 这样的 trait 类有很多，可以用来在模板里决定所需的特殊行为：
is_array
is_enum
is_function
is_pointer
is_reference
is_const
has_virtual_destructor
…
这些特殊行为判断可以是像上面这样用于决定不同的重载，也可以是直接用在模板参数甚至代码里（记得我们是可以直接得到布尔值的）。
除了得到布尔值和相对应的类型的 trait 模板，我们还有另外一些模板，可以用来做一些类型的转换。以一个常见的模板 remove_const 为例（用来去除类型里的 const 修饰），它的定义大致如下：
template <class T>
struct remove_const {
typedef T type;
};
template <class T>
struct remove_const<const T> {
typedef T type;
};
同样，它也是利用模板的特化，针对 const 类型去掉相应的修饰。比如，如果我们对 const string 应用 remove_const，就会得到 string，即，remove_const<const string>::type 等价于 string。
这里有一个细节你要注意一下，如果对 const char* 应用 remove_const 的话，结果还是 const char*。原因是，const char* 是指向 const char 的指针，而不是指向 char 的 const 指针。如果我们对 char * const 应用 remove_const 的话，还是可以得到 char* 的。

简易写法

如果你觉得写 is_trivially_destructible<T>::value 和 remove_const<T>::type 非常啰嗦的话，那你绝不是一个人。在当前的 C++ 标准里，前者有增加 _v 的编译时常量，后者有增加 _t 的类型别名：
template <class T>
inline constexpr bool
is_trivially_destructible_v =
is_trivially_destructible<
T>::value;
template <class T>
using remove_const_t =
typename remove_const<T>::type;
至于什么是 constexpr，我们会单独讲。using 是现代 C++ 的新语法，功能大致与 typedef 相似，但 typedef 只能针对某个特定的类型，而 using 可以生成别名模板。目前我们只需要知道，在你需要 trait 模板的结果数值和类型时，使用带 _v 和 _t 后缀的模板可能会更方便，尤其是带 _t 后缀的类型转换模板。

通用的 fmap 函数模板

你应当多多少少听到过 map-reduce。抛开其目前在大数据应用中的具体方式不谈，从概念本源来看，map [3] 和 reduce [4] 都来自函数式编程。下面我们演示一个 map 函数（当然，在 C++ 里它的名字就不能叫 map 了），其中用到了目前为止我们学到的多个知识点：
template <
template <typename, typename>
class OutContainer = vector,
typename F, class R>
auto fmap(F&& f, R&& inputs)
{
typedef decay_t<decltype(
f(*inputs.begin()))>
result_type;
OutContainer<
result_type,
allocator<result_type>>
result;
for (auto&& item : inputs) {
result.push_back(f(item));
}
return result;
}
我们：
用 decltype 来获得用 f 来调用 inputs 元素的类型（参考[第 8 讲]）；
用 decay_t 来把获得的类型变成一个普通的值类型；
缺省使用 vector 作为返回值的容器，但可以通过模板参数改为其他容器；
使用基于范围的 for 循环来遍历 inputs，对其类型不作其他要求（参考[第 7 讲]）；
存放结果的容器需要支持 push_back 成员函数（参考[第 4 讲]）。
下面的代码可以验证其功能：
vector<int> v{1, 2, 3, 4, 5};
int add_1(int x)
{
return x + 1;
}
auto result = fmap(add_1, v);
在 fmap 执行之后，我们会在 result 里得到一个新容器，其内容是 2, 3, 4, 5, 6。

内容小结

本讲我们介绍了模板元编程的基本概念和例子，其本质是把计算过程用编译期的类型推导和类型匹配表达出来；然后介绍 type traits 及其基本用法；最后我们演示了一个简单的高阶函数 map，其实现中用到了我们目前已经讨论过的一些知识点。

课后思考

这一讲的内容可能有点烧脑，请你自行实验一下例子，并找一两个简单的算法用模板元编程的方法实现一下，看看能不能写出来。
如果有什么特别想法的话，欢迎留言和我分享交流。

参考资料

[1] Todd L. Veldhuizen, “C++ templates are Turing complete”. http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.14.3670
[2] cppreference.com, “Standard library header <type_traits>”. https://en.cppreference.com/w/cpp/header/type_traits
[2a] cppreference.com, “标准库头文件 <type_traits>”. https://zh.cppreference.com/w/cpp/header/type_traits
[3] Wikipedia, “Map (higher-order function)”. https://en.wikipedia.org/wiki/Map_(higher-order_function)
[4] Wikipedia, “Fold (higher-order function)”. https://en.wikipedia.org/wiki/Fold_(higher-order_function)
分享给需要的人，Ta购买本课程，你将得18元
生成海报并分享

赞 7

提建议

© 版权归极客邦科技所有，未经许可不得传播售卖。 页面已增加防盗追踪，如有侵权极客邦将依法追究其法律责任。
上一篇
12 | 编译期多态：泛型编程和模板入门
下一篇
14 | SFINAE：不是错误的替换失败是怎么回事?
 写留言

精选留言(28)

  • 禾桃
    2019-12-25
    脑壳儿疼的兄弟姐妹们，我这有个小偏方， 哈哈 While< Sum<2>::type >::type::value 实例化(instantiation)过程 --> While< SumLoop<0, 2> >::type::value --> WhileLoop<SumLoop<0, 2>::cond_value, SumLoop<0, 2>>::type::value --> WhileLoop<true, SumLoop<0, 2>>::type::value --> WhileLoop<SumLoop<0, 2>::cond_value, SumLoop<0, 2>::next_type>::type::value --> WhileLoop<true, SumLoop<2, 1>>::type::value --> WhileLoop<SumLoop<2, 1>::cond_value, SumLoop<2, 1>::next_type>::type::value --> WhileLoop<true, SumLoop<3, 0>>::type::value --> WhileLoop<SumLoop<3, 0>::cond_value, SumLoop<3, 0>::next_type>::type::value --> WhileLoop<false, SumLoop<3, -1>>::type::value --> SumLoop<3, -1>::res_type::value -->integral_constant<int, 3>::value -->3
    展开

    作者回复: 对，对于模板，就是要在脑子里或纸上、电脑上把它展开……☺️

    12
  • 总统老唐
    2019-12-25
    记得吴老师之前预告过，这一节可能会比较难，确实被难住了。在第一个 If 模板这里就被卡住了，老师能给个简单的例子来说明这个 If 模板该如何使用么？

    作者回复: 下面的函数和模板是基本等价的： int foo(int n) { if (n == 2 || n == 3 || n == 5) { return 1; } else { return 2; } } template <int n> struct Foo { typedef typename If< (n == 2 || n == 3 || n == 5), integral_constant<int, 1>, integral_constant<int, 2>>::type type; }; 你可以输出 foo(3)，也可以输出 Foo<3>::type::value。

    8
  • 莫言
    2021-12-27
    template < template <typename, typename> class OutContainer = vector, typename F, class R> 请问老师，这个OutConContainer前面的template<typename,typename>应该怎么理解

    作者回复: 模板的参数可以是类型（如 int），可以是值（如长度 8），也可以是其他（类或别名）模板。这个语法代表 OutContainer 是一个带两个类型模板参数的（类或别名）模板。（vector 有两个类型模板参数，第二个有默认值，一般不需要自己提供。）

    2
  • chang
    2021-06-03
    比如，如果我们对 const string& 应用 remove_const，就会得到 string&，即，remove_const::type 等价于 string&。 remove_const只能去顶层const。const string&应用remove_const后还是const string&，const string应用remove_const后是string。

    作者回复: 谢谢抓虫🙏。

    1
  • 鲁·本
    2020-10-11
    对While<Sum<10>::type>::type::value进行手动推导，最终是能推导出实际语句是 integral_constant<int，10+9+...1>::value的，但让我独立写出 完整的代码是万万不能的😄

    作者回复: 哈哈，我写的时候头也很大。只是为了说明能写出来，而不是真想/需要这么写。

    1
  • 吃鱼
    2020-06-02
    “如果要得到布尔值的话，当然使用 `is_trivially_destructible::value` 就可以，但此处不需要。需要的是，使用 `()` 调用该类型的构造函数，让编译器根据数值类型来选择合适的重载。这样，在优化编译的情况下，编译器可以把不需要的析构操作彻底全部删除。” 老师，这里没太懂，使用 `()` 调用该类型的构造，这里的调用是在哪里调用，为什么 destroy 要调用构造函数

    作者回复: 指的就是这句： _destroy(ptr, is_trivially_destructible<T>()) 这儿构造了一个 true_type 或 false_type 的对象，然后编译器会根据第二个参数的类型，决定调用 _destroy 的哪个重载。

    共 3 条评论
    1
  • YouCompleteMe
    2020-01-16
    template <typename Body> struct whileLoop<true, Body> 部分似乎改成下面这样，更直观， 编译时计算更少呢 template <typename Body> struct whileLoop<true, Body> { typedef typename whileLoop< Body::next_type::cond_value, typename Body::next_type>::type type; };
    展开

    作者回复: 嗯，是的，你的写法能少展开一次。👍

    1
  • 吃一个芒果
    2020-01-02
    template <int num1, int num2> struct Add_ { const static int res = num1 + num2; }; template <int num1, int num2> struct Sub_ { const static int res = num1 - num2; }; template <bool Condition> struct If_; template <> struct If_ <true> { template<int num1, int num2> using type = Add_<num1, num2>; }; template <> struct If_ <false> { template<int num1, int num2> using type = Sub_<num1, num2>; }; template<int num1, int num2> template<bool Condition> using If = typename If_<Condition>::template type<num1, num2>; template<int num1, int num2> using True = If<true>; template<int num1, int num2> using False = If<false>; 老师你好，我想问一个语法方面可能比较钻牛角尖的问题 我定义了If_,用来在true和false的时候返回不同的模板。又定义了True和False，这样就可以通过True<a, b>::res或者False<a, b>::res来获取不同模板的计算结果。但是如果我想用类似If<condition><a, b>::res这样的调用（不知道我表达清楚没有）来获取不同的结果（在不改If_定义的情况下），应该怎么写呢？谢谢！
    展开

    作者回复: 你希望的写法我觉得是写不出来的，而且意义似乎也不大？下面这样写似乎表达能力是一样的，并且可以过： template <bool Condition, int num1, int num2> using If = typename If_<Condition>:: template type<num1, num2>; template <int num1, int num2> using True = If<true, num1, num2>; template <int num1, int num2> using False = If<false, num1, num2>;

    1
  • 总统老唐
    2019-12-27
    吴老师，关于最后这个例子，有两个小问题： 1，我们平时定义一个 vector 的时候，一般并不会写成 vector<int, allocator<int>> vec 这种形式，为什么模板函数里面定义返回值 result 时，需要多一个 allocator？ 2，fmap函数的入参和for循环，全都用的右值引用，有什么特殊考量么？

    作者回复: 1. 因为模板的定义就是这个样子，虽然我们平时第二个参数用的都是默认模板参数。 2. 不是右值引用，是转发引用。复习一下第 3 讲结尾部分吧。

    1
  • 陈狄
    2022-04-29
    编译期编程确实6，模版写循环确实绕，展开如下： While<Sum<10>::type>::type::value While<SumLoop<0, 10>>::type::value WhileLoop<SumLoop<0, 10>::cond_value, SumLoop<0, 10>>::type::value WhileLoop<true, SumLoop<0, 10>>::type::value WhileLoop<SumLoop<0, 10>::cond_value, SumLoop<0, 10>::next_type>::type::value WhileLoop<true, SumLoop<10, 9>>::type::value WhileLoop<SumLoop<10, 9>>::cond_value,SumLoop<10, 9>>::next_type>::type::value ... WhileLoop<SumLoop<55, 0>>::cond_value,SumLoop<55, 0>>::next_type>::type::value WhileLoop<false,SumLoop<55, -1>>::type::value SumLoop<55, -1>::res_type::value integral_constant<int, 55>::value
    展开

    作者回复: 我自己写完都不想看这代码了……只是想练习一下确实可以写出循环。

  • Geek_15f2c9
    2021-04-28
    老师，对万能引用使用完美转发是否好点，result.push_back(std::forward<decltype(f(item))>(f(item)))或result.emplace_back(std::forward<decltype(f(item))>(f(item)));;

    作者回复: 很好的问题。但是，实际必要性不高。 原因是，f(…) 极少会有合法的、返回右值引用的场景。唯一我能想到的可能性是返回值是根据输入的右值生成的情况。这样的话，得保证在输入是个右值容器时传递元素的右值给 f，所以真要考虑这种情况的话，代码比你写的还要再复杂不少……

  • 王旧业
    2021-02-17
    While<Sum<10>::type>::type::value的例子中会使用到了自己integral_constant模板，但是stl中也有一份integral_constant，所以运行本示例代码时如果一开始直接 using namespace std会编译报错

    作者回复: 我给出的定义只是给大家直观地看一下。生产代码应该使用标准库。 不过，生产代码一般也不建议使用 using namespace std; 哦。

  • Gazelle
    2020-11-29
    我实践写了下remove_const，好像没有把const去掉。这里是不是有点问题呢？ https://stackoverflow.com/questions/15887144/stdremove-const-with-const-references 我看这里说是如果同时有const和引用的话，还需要去掉引用？ std::remove_const<std::remove_reference<const string&>::type>::type

    作者回复: 这里有个小细节：const T& 等同于 T const&，但和 T& const 不同。前者是一个指向常量的引用，后者是一个常引用。只有后者才被看作是一个“常量”。

  • talor
    2020-08-07
    脑子烧坏了

    作者回复: 是有点烧。搞明白了就是个新世界。

  • Geek_68d3d2
    2020-08-04
    typedef SumLoop<0, n> type;这个语法不是给类型定义别名吗 怎么代码里变成了变量定义???

    作者回复: 还是类型。但在模板元编程里，玩的就是利用类型推导来做计算。所以类型是当成变量来用的。 哈哈，有点绕，慢慢看。😄

    共 2 条评论
  • zhengfan
    2020-07-07
    这一课看的脑浆都沸腾了…… 吴老师，您好。有如下几个问题请教一下： 在SumLoop中定义的res_value的目的是什么？为什么不直接使用 typedef integral_constant<int, result> res_type 而是 typedef integral_constant<int, res_value> res_type呢？前者编译执行都没有问题的。 在integral_constant定义typedef integral_constant type目的是什么？ 另外我尝试稍微改动了一下文中例子如下： template <class T, T v> struct type_constant { static const T value = v; typedef T value_type; typedef type_constant type; }; template <typename T, T result, T n> struct SumLoop { static const bool cond_value = (n > (T)0); // static const int res_value = result; typedef type_constant<T, result> res_type; typedef SumLoop<T, result + n, n - (T)1> next_type; }; template <typename T, T n> struct Sum { typedef SumLoop<T, (T)0, n> type; }; 结果发现只能够支持范整型类型如int,size_t,ulong等等： While<Sum<size_t, 10>::type>::type::value编译执行工作正常；但对于浮点型如： While<Sum<float, 10.0)>::type>::type::value编译报错： error: ‘float’ is not a valid type for a template non-type parameter 请问这是什么原因？
    展开

    作者回复: 对我来讲，res_type 和 res_value 是同一个值的两种不同表现方式。目前这种写法，于我更为自然些。你的写法也没有问题。 浮点数由于精度问题，目前在 C++ 里不允许用作模板参数。可以参考这个讨论 https://stackoverflow.com/questions/2183087/why-cant-i-use-float-value-as-a-template-parameter

  • 范闲
    2020-03-31
    最近在看STl源码分析。 1.一直再想allocator类为什么要存在？ 为不同的容器类型提供了内存资源管理类，同时也支持用户自定义，更方便和灵活。实际上对于容器而言内部的资源都是分布在对上的，栈上的只不过是个符号。 2.为什么要有type_traits？ iterator是对容器类的一种底层抽象.type_traits实际上也是这样的抽象，只不过更抽象。
    展开

    作者回复: 1. 确实是为了灵活，但这个设计不能算很成功，因为真的用的人非常少。但从理论上来讲，你用 allocator 可以实现非常特别的内存管理策略，如预分配之类。 2. 迭代器实际上是比容器更抽象的概念，第 7 讲介绍的 istream_line_reader 就不能说是个容器。第 29 讲有比容器更抽象的“范围”。type_traits 翻译成中文是“类型特点”，是各种对共性的描述，是一组非常散的概念，跟迭代器、容器之类相提并论我觉得不妥。

  • czh
    2020-02-03
    类比刚学函数时的感觉。模板类型推导=函数嵌套，用于提供逻辑过程；计算过程由参数传递的过程中进行。逻辑+计算，这样就完成了模板计算。
  • oozero
    2020-02-03
    老师可以将文中示例代码片段整理成文件，分享到GitHub，让c++基础不扎实的同学可以更直观的学习吗？

    作者回复: 那要花时间整理了……后半部分的代码我比较全点，前半部分一开始没有保留所有的测试代码……

  • 光城~兴
    2020-01-05
    在文中提到这么一句话：“实际上，到现在为止，我们讲的东西还没有离开 C++98。而我们下面几讲里很快就会讲到，如何在现代 C++ 里不使用这种麻烦的方式也能达到同样的效果。” 想问一下如果用现代C++实现上述的IF或者WhileLoop，究竟跟上述的有什么区别。

    作者回复: 没区别。 要点是你不需要使用这些模板，也同样能达到编译期编程的效果。