人们往往会将一个大问题拆解成许多小问题，通过解决一个个小问题，最终就能解决整个大问题。

(资料图片仅供参考)

若是拆解过后，这些小问题的处理逻辑不变，变化的只是输入状态，那么此时就是一种代码复用。对应编程世界，一种是自上而下的拆解组合方式，称为递归；一种是自下而上的拆解组合方式，称为迭代。

拆解后还能组合，拆解才有意义，递归和迭代本身就带有一种约束，必须具备起始状态和终止状态。若是没有起始状态，递归就没有起点，循环就没有开始；若是没有终止状态，递归就没有终点，循环就没有结束，

本文所说的元编程拆解技术，就是编译期的问题拆解与组合技术，编译期不像运行期那样能够动态地改变输入与输出状态，C++诞生了许多技术来解决这个问题，这便是后文要介绍的。

本文以一个需求为例，来讲解这些技术：

要求编写一个 unroll(callback) 函数，该函数将调用 N 次传入的 callback 函数。

起始状态就是 N，终止状态就是 N 为零，拆解后处理逻辑不变的小问题就是 callback。

先不看文，你首先想到的是什么解法？文读毕，对比一下文中的各种拆解技术思路，获益更多。

原始递归法

模板元编程最开始就只支持递归这一种拆解方式，每次输入一个状态，依次产生下一个状态，若状态与递归终止状态相同，则结束。

采用这种方式，实现需求如下：

1namespacecpp98{ 2 3//declaration 4templatevoidunroll(F); 5 6template7structunroll_helper{ 8voidoperator()(Ff){ 9f();10unroll(f);11}12};1314//terminatedstate15template16structunroll_helper<0,F>{17voidoperator()(F){}18};1920//definition21template22voidunroll(Ff){23unroll_helper()(f);24}2526voidprint_cpp98(){27std::puts("hellocpp98");28}29}3031intmain(){32cpp98::unroll<2>(cpp98::print_cpp98);33//output:34//hellocpp9835//hellocpp9836}

由于函数模板不支持偏特化，于是需要借助一个 unroll_helper 类模板，来实现递归终止条件，再在 unroll 函数中调用该帮助类，不断拆解问题。

递归输入条件 N 为起始状态，每次拆解执行完成之后，通过 N - 1 得到下一个状态，从而不断解决问题。

这个时期，C++ 的元编程拆解技术还很弱，一个简单的需求，实现起来也颇为繁琐。

可变参数模板

时间来到 C++11，模板元编程迎来强大扩展，非常有用的一个新特性就是可变参数模板，它能够让我们摆脱递归这种原始拆解方式。

但是 C++11 还只是开始，基础组件不完善，所以并不能非常有效地实现目标。

什么意思呢？看如下这个不太完善的实现：

1namespacecpp11{ 2 3template4classindex_sequence{}; 5 6template7voidunroll(Ff,index_sequence){ 8usingexpand=std::size_t[]; 9expand{(f(),Is)...};10}1112}131415intmain(){16cpp11::unroll([]{std::puts("hellocpp11");},17cpp11::index_sequence<2,1>());18}

原始递归法是采用不断递归来动态地产生状态，而有了可变参数模板，状态可以直接在编译期初期产生，从而直接拿来用就可以。

这里定义了一个 index_sequence 用来接收所有状态，然后借助一些逗号表达式技巧展开参数包，在参数包展开的过程当中，执行处理逻辑。

C++11 起也支持 Lambda，因此也不用再提供一个额外的调用函数。

这个实现的唯一缺点就是由于缺乏相应的组件，需要手动产生状态，导致使用起来较为麻烦。

完善版可变参数模板

C++14 增加了 std::index_sequence 和 std::make_index_sequence，于是就能将手动产生状态变成动态产生，完善实现。

代码如下：

1namespacecpp14{ 2 3template4voidhelper(Ff,std::index_sequence){ 5usingexpand=std::size_t[]; 6expand{(f(),Is)...}; 7} 8 9//variabletemplate10template11autounroll=[](autof){//genericlambda12helper(f,std::make_index_sequence{});13};14}1516intmain(){17cpp14::unroll<3>([]{std::puts("hellocpp14");});18}

同时，C++14 还支持 variable template 和 generic lambda，这进一步简化了实现。

Fold Expression

前面的方式是采用逗号表达式技巧来展开参数包，C++17 支持 Fold expression，可以直接展开，因此代码得到进一步简化。

变成：

1namespacecpp17{ 2 3template4voidhelper(Ff,std::index_sequence){ 5((f(),Is),...);//foldexpression 6} 7 8template9autounroll=[](autof){//genericlambda10helper(f,std::make_index_sequence{});11};12}

constexpr if

C++17 的另一种拆解技术是借助 constexpr if，它的好处在于能够直接在本函数内判断终止状态，这样就不再需要去定义一个递归终止函数。

1namespacecpp17{ 2//variabletemplate+constexprif 3template4autounroll=[](autoexpr){ 5ifconstexpr(N){ 6expr(); 7unroll(expr); 8} 9};10}1112intmain(){13cpp17::unroll<3>([]{std::puts("hellocpp17");});14}

与原始递归法相比，这种方式除了消除递归终止函数，还免于编写一个额外的 helper 类，generic lambda 更是减少了模板参数。

这是目前为止，最简洁的实现。

C++20 双层 Lambda 法

有没有非递归的简洁拆解方式呢？当然也有。

看如下实现：

1namespacecpp20{ 2 3templateconstexprautounroll=[](autof){ 4[f](std::index_sequence){ 5((f(),void(Is)),...); 6}(std::make_index_sequence()); 7}; 8} 910intmain(){11cpp20::unroll<3>([]{std::puts("hellocpp20");});12}

这里的关键是 C++20 的 template lambda，它支持为 lambda 编写模板参数，基于此才能够编写索引的模板参数。

Lambda 函数里面再套一个 Lambda 函数，外层用于提供调用接口，内层用于管理状态和处理调用。如果没有 template lambda，内层 Lambda 的 std::index_sequence 参数就无法写，也就接收不了状态。、

Structured Binding Packs

原本有些新特性是应该在 C++23 就进入标准的，但由于种种原因，我们只有期望 C++26 能用上了。Structured binding packs 就是这么一个特性。

前面除了递归以外的所有拆解方法，都得借助 std::index_sequence，这就是代码依旧复杂的原因所在。

有没有一种方式可以直接让我们访问参数包，而不必再定义一个参数为 std::index_sequence 的函数才能拿到那些参数包？Structured binding packs 就提供了这一能力。

这是 P1061 所提出的一种方式，让我们能够通过 Structured bindings 直接得到参数包。

于是实现变为：

1namespacep1061{ 2 3templateconstexprautounroll=[](autof){ 4auto[...Is]=std::make_index_sequence(); 5((f(),void(Is)),...); 6}; 7 8} 910intmain(){11p1061::unroll<3>([]{std::puts("hellop1061");});12}

这种拆解技术才是最直观的方式，两行代码解决一切。

Expansion Statements

另外一种方式就是我们在反射中经常使用到的一个特性：template for。

这种方式比 Structured Binding Packs 更强大，是静态反射里面的一个扩展特性，能够支持编译期迭代。

对于本次需求的实现为：

1namespacep1306{ 2templateconstexprautounroll=[](autof){ 3constexprstd::arraydummy{}; 4templatefor(auto&e:dummy) 5f(); 6}; 7} 8 9intmain(){10p1306::unroll<3>([]{std::puts("hellop1306");});11}

这里借助了 std::array，构建了一个并不会实际使用的变量，目的是为了当作遍历次数。

总结

本文从 C++98 开始介绍了许多拆解技术，在不断的优化过程中，也能够看到 C++ 的发展历程。

由最原始的复杂、难用，到最后的两行代码搞定，也能够看到 C++ 元编程的发展。

利用好这些技术，对大家的元编程能力会有显著提高。

审核编辑：汤梓红