電子發燒友App
人們往往會將一個大問題拆解成許多小問題，通過解決一個個小問題，最終就能解決整個大問題。
若是拆解過后，這些小問題的處理邏輯不變，變化的只是輸入狀態，那么此時就是一種代碼復用。對應編程世界，一種是自上而下的拆解組合方式，稱為遞歸；一種是自下而上的拆解組合方式，稱為迭代。
拆解后還能組合，拆解才有意義，遞歸和迭代本身就帶有一種約束，必須具備起始狀態和終止狀態。若是沒有起始狀態，遞歸就沒有起點，循環就沒有開始；若是沒有終止狀態，遞歸就沒有終點，循環就沒有結束，
本文所說的元編程拆解技術，就是編譯期的問題拆解與組合技術，編譯期不像運行期那樣能夠動態地改變輸入與輸出狀態，C++ 誕生了許多技術來解決這個問題，這便是后文要介紹的。
本文以一個需求為例，來講解這些技術：
要求編寫一個 unroll
起始狀態就是 N，終止狀態就是 N 為零，拆解后處理邏輯不變的小問題就是 callback。
先不看文，你首先想到的是什么解法？文讀畢，對比一下文中的各種拆解技術思路，獲益更多。
原始遞歸法
模板元編程最開始就只支持遞歸這一種拆解方式，每次輸入一個狀態，依次產生下一個狀態，若狀態與遞歸終止狀態相同，則結束。
采用這種方式，實現需求如下：
?
1namespace?cpp98?{
2
3????//?declaration
4????template??void?unroll(F);
5
6????template?
7????struct?unroll_helper?{
8????????void?operator()(F?f)?{
9????????????f();
10????????????unroll(f);
11????????}
12????};
13
14????//?terminated?state
15????template?
16????struct?unroll_helper<0,?F>?{
17????????void?operator()(F)?{}
18????};
19
20????//?definition
21????template?
22????void?unroll(F?f)?{
23????????unroll_helper()(f);
24????}
25
26????void?print_cpp98()?{
27????????std::puts("hello?cpp98");
28????}
29}
30
31int?main()?{
32????cpp98::unroll<2>(cpp98::print_cpp98);
33????//?output:
34????//?hello?cpp98
35????//?hello?cpp98
36}
?
由于函數模板不支持偏特化，于是需要借助一個 unroll_helper 類模板，來實現遞歸終止條件，再在 unroll 函數中調用該幫助類，不斷拆解問題。
遞歸輸入條件 N 為起始狀態，每次拆解執行完成之后，通過 N - 1 得到下一個狀態，從而不斷解決問題。
這個時期，C++ 的元編程拆解技術還很弱，一個簡單的需求，實現起來也頗為繁瑣。
可變參數模板
時間來到 C++11，模板元編程迎來強大擴展，非常有用的一個新特性就是可變參數模板，它能夠讓我們擺脫遞歸這種原始拆解方式。
但是 C++11 還只是開始，基礎組件不完善，所以并不能非常有效地實現目標。
什么意思呢？看如下這個不太完善的實現：
?
1namespace?cpp11?{
2
3????template?
4????class?index_sequence?{};
5
6????template?
7????void?unroll(F?f,?index_sequence)?{
8????????using?expand?=?std::size_t[];
9????????expand{?(f(),?Is)...?};
10????}
11
12}
13
14
15int?main()?{
16????cpp11::unroll([]?{?std::puts("hello?cpp11");?},
17????????cpp11::index_sequence<2,?1>());
18}
?
原始遞歸法是采用不斷遞歸來動態地產生狀態，而有了可變參數模板，狀態可以直接在編譯期初期產生，從而直接拿來用就可以。
這里定義了一個 index_sequence 用來接收所有狀態，然后借助一些逗號表達式技巧展開參數包，在參數包展開的過程當中，執行處理邏輯。
C++11 起也支持 Lambda，因此也不用再提供一個額外的調用函數。
這個實現的唯一缺點就是由于缺乏相應的組件，需要手動產生狀態，導致使用起來較為麻煩。
完善版可變參數模板
C++14 增加了 std::index_sequence 和 std::make_index_sequence，于是就能將手動產生狀態變成動態產生，完善實現。
代碼如下：
?
1namespace?cpp14?{
2
3????template?
4????void?helper(F?f,?std::index_sequence)?{
5????????using?expand?=?std::size_t[];
6????????expand{?(f(),?Is)...?};
7????}
8
9????//?variable?template
10????template?
11????auto?unroll?=?[](auto?f)?{?//?generic?lambda
12????????helper(f,?std::make_index_sequence{});
13????};
14}
15
16int?main()?{
17????cpp14::unroll<3>([]?{?std::puts("hello?cpp14");?});
18}
?
同時，C++14 還支持 variable template 和 generic lambda，這進一步簡化了實現。
Fold Expression
前面的方式是采用逗號表達式技巧來展開參數包，C++17 支持 Fold expression，可以直接展開，因此代碼得到進一步簡化。
變成：
?
1namespace?cpp17?{
2
3????template?
4????void?helper(F?f,?std::index_sequence)?{
5????????((f(),?Is),?...);?//?fold?expression
6????}
7
8????template?
9????auto?unroll?=?[](auto?f)?{?//?generic?lambda
10????????helper(f,?std::make_index_sequence{});
11????};
12}
?
constexpr if
C++17 的另一種拆解技術是借助 constexpr if，它的好處在于能夠直接在本函數內判斷終止狀態，這樣就不再需要去定義一個遞歸終止函數。
?
1namespace?cpp17?{
2????//?variable?template?+?constexpr?if
3????template?
4????auto?unroll?=?[](auto?expr)?{
5????????if?constexpr?(N)?{
6????????????expr();
7????????????unroll(expr);
8????????}
9????};
10}
11
12int?main()?{
13????cpp17::unroll<3>([]?{?std::puts("hello?cpp17");?});
14}
?
與原始遞歸法相比，這種方式除了消除遞歸終止函數，還免于編寫一個額外的 helper 類，generic lambda 更是減少了模板參數。
這是目前為止，最簡潔的實現。
C++20 雙層 Lambda 法
有沒有非遞歸的簡潔拆解方式呢？當然也有。
看如下實現：
?
1namespace?cpp20?{
2
3????template??constexpr?auto?unroll?=?[](auto?f)?{
4????????[f](std::index_sequence)?{
5????????????((f(),?void(Is)),?...);
6????????}(std::make_index_sequence());
7????};
8}
9
10int?main()?{
11????cpp20::unroll<3>([]?{?std::puts("hello?cpp20");?});
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 直接得到參數包。
于是實現變為：
?
1namespace?p1061?{
2
3????template??constexpr?auto?unroll?=?[](auto?f)?{
4????????auto?[...?Is]?=?std::make_index_sequence();
5????????((f(),?void(Is)),?...);
6????};
7
8}
9
10int?main()?{
11????p1061::unroll<3>([]?{?std::puts("hello?p1061");?});
12}
?
這種拆解技術才是最直觀的方式，兩行代碼解決一切。
Expansion Statements
另外一種方式就是我們在反射中經常使用到的一個特性：template for。
這種方式比 Structured Binding Packs 更強大，是靜態反射里面的一個擴展特性，能夠支持編譯期迭代。
對于本次需求的實現為：
?
1namespace?p1306?{
2????template??constexpr?auto?unroll?=?[](auto?f)?{
3????????constexpr?std::array?dummy{};
4????????template?for?(auto&?e?:?dummy)
5????????????f();
6????};
7}
8
9int?main()?{
10????p1306::unroll<3>([]?{?std::puts("hello?p1306");?});
11}
?
這里借助了 std::array，構建了一個并不會實際使用的變量，目的是為了當作遍歷次數。
總結
本文從 C++98 開始介紹了許多拆解技術，在不斷的優化過程中，也能夠看到 C++ 的發展歷程。
由最原始的復雜、難用，到最后的兩行代碼搞定，也能夠看到 C++ 元編程的發展。
利用好這些技術，對大家的元編程能力會有顯著提高。
審核編輯：湯梓紅
工商網監
評論