tuple是c++11新增的資料結構，通過tuple我們可以方便地把各種不同型別的資料組合在一起，有了這樣的資料結構我們就可以輕松模擬多值回傳等技巧了，
tuple和其他的容器不同，標準庫沒有提供適用于tuple的迭代器，也沒有提供tuple型別的迭代介面，所以當我們想要遍歷tuple的時候只能自己動手了，
所以這篇文章我們會實作一個簡單的介面用來遍歷各種tuple，順便一窺現代c++中的模板元編程，
本文索引
- 介面設計
- 實作介面
- 初步嘗試
- 通用的古典實作
- 使用編譯期條件分支
- 變長模板引數——錯誤的解法
- 折疊運算式——使用變長模板引數的正確解法
- 總結
介面設計
為什么要遍歷tuple呢？通常我們確實不需要逐個遍歷tuple的資料，通過使用get取出特定位置的元素就滿足大部分的應用需求了，
但偶爾我們也會想要把某一個泛型演算法應用到tuple的每一項成員上，雖然不多見但也確實有需求的場景存在，因此如何實作對tuple的遍歷就被擺上了議程，
然而遺憾的是get需要的索引只能是編譯期常量，這導致我們無法依賴現有的回圈陳述句去實作索引的遞增，因此只有兩條路可供選擇：硬編碼每一項索引和模板元編程，我是個不喜歡硬編碼的人，所以我選擇了后者，
把STL里的通用容器演算法實作一遍工程量太大了，而且很明顯一篇文章也講不完，我決定實作標準庫里的for_each，正好也契合今天的主題——遍歷tuple，
標準庫的for_each是這樣的template <class Iterator, class UnaryFunction> void for_each(Iterator first, Iterator last, UnaryFunction f)，其中UnaryFunction的函式簽名是void fun(const Type &a)，
通過for_each我們可以順序遍歷容器中的每一項資料，我們的for_each_tuple也將實作類似的功能——順序遍歷tuple的每一項元素，
不過前面已經提到了，tuple是沒有迭代器的，因此我們的函式得改個樣子：template <class Tuple, class Functor> void for_each_tuple(const Tuple &, Functor &&)，因為不能使用迭代器，所以我們傳了tuple的參考進函式，
當然，c++17里tuple是constexpr型別，所以你還可以給我們的for_each加上constexpr，
函式內部要做的事其實也很簡單，就是對每一項元素呼叫f即可，在這里我們不考慮其他一些細節，我們的介面形式上應該是這樣子的（偽代碼）：
template <class Tuple, class Functor>
constexpr void for_each_tuple(const Tuple &t, Functor &&f)
{
for element in t {
f(t);
}
}
實作介面
介面設計好了，下面我們就該實作for element in t的部分了，
接下來我會介紹三種實作遍歷tuple的方法，以及一種存在缺陷的方法，首先我們從最原始的方案開始，
初步嘗試
距離c++11發布已經快整整十年了，想必大家也習慣于書寫c++11的代碼了，不過讓我們把時間倒流回c++11前的時代，那時候既沒有constexpr，也沒有變長模板引數，相當的原始而蠻荒，
那么問題來了，那時候有tuple嗎？當然有，boost里的tuple的歷史在c++11前就已經開始了，
其中的秘訣就在于模板遞回，這是一種經典的元編程手段，解鈴還須系鈴人，我們的foreach也需要借助這種技術，
現在我們來看一下不使用編譯期計算和變長模板引數的原始方案：
template <typename Tuple, typename Functor, int Index>
void for_each_tuple_impl(Tuple &&t, Functor &&f)
{
if (Index >= std::tuple_size<std::remove_reference_t<Tuple>>::value) {
return;
} else {
f(std::get<Index>(t));
for_each_tuple_impl<Tuple, Functor, Index+1>(std::forward<Tuple>(t), std::forward<Functor>(f));
}
}
template <typename Tuple, typename Functor>
void for_each_tuple(Tuple &&t, Functor &&f)
{
for_each_tuple_impl<Tuple, Functor, 0>(std::forward<Tuple>(t), std::forward<Functor>(f));
}
我們用std::remove_reference_t來把Tuple從參考型別轉化為被參考的tuple的型別，原因是模板函式的右值參考引數會自動根據參考折疊的規則轉換為左值參考或者右值參考，而我們不能從參考型別呼叫std::tuple_size獲取tuple的長度，
整體的思路其實很簡單，我們從0開始，每遍歷處理完一項就讓index+1，然后遞回呼叫impl，如果了最后一個元素+1的位置，函式就回傳，這樣遍歷就結束了，
注意f上的std::forward，我們用右值參考的目的是接受包括lambda在內的所有可呼叫物件，這些物件可以是一個lambda字面量，可以是一個具名的存盤了lambda的變數，還以可以是函式指標或者任何多載了template <typename T> void operator()(const T&)運算子的類的實體，所以我們很難假設這么廣范圍內的可呼叫物件都是可以被復制的，所以保險起見我們使用了模板的右值引引數來將不可以復制的內容用右值參考捕獲，當然因為移動語意會產生副作用，這點用戶得自己負擔，而我們也不得不對f使用std::forward進行完美轉發，不過這樣好處也不是沒有，至少我們省去了很多不必要的復制，
然而當你滿心歡喜地準備嘗試運行自己杰作的時候，編譯器給你澆了一頭冷水：
...
/usr/include/c++/10.2.0/tuple:1259:12: fatal error: template instantiation depth exceeds maximum of 900 (use '-ftemplate-depth=' to increase the maximum)
1259 | struct tuple_element<__i, tuple<_Head, _Tail...> >
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
compilation terminated.
報了一大堆錯，甚至超過了螢屏的最大滾動高度（我設定的是10000行），發生了什么呢？
稍微翻翻報錯資訊，我們發現了實際上是模板遞回超過了允許的最大深度，可是我們不是已經給出了退出遞回的條件了嗎？
讓我再來看看impl的代碼：
template <typename Tuple, typename Functor, int Index>
void for_each_tuple_impl(Tuple &&t, Functor &&f)
{
if (Index >= std::tuple_size<std::remove_reference_t<Tuple>>::value) {
return;
} else {
f(std::get<Index>(t));
// 注意下面這行
for_each_tuple_impl<Tuple, Functor, Index+1>(std::forward<Tuple>(t), std::forward<Functor>(f));
}
}
編譯器在編譯函式的時候是需要把所有條件分支都編譯的，所以即使是在函式模板的實體達到退出遞回的條件，else分支仍然會被編譯，而在這個分支里模板會被不斷遞回實體化，最終超過允許的最大遞回深度，
這里就引出了模板遞回的一個重要規則：我們應該用模板特化或是函式多載來實作遞回的終止條件
然而在這里我們既不是模板的特化也沒有呼叫多載函式，
如果想利用函式多載的話并不現實，因為遞回函式呼叫的形式是相同的，無法針對tuple的最后一個元素進行特殊處理，
而函式模板不支持部分特化，所以我們也很難實作一個針對tuple結尾的特化版本，
那怎么辦呢？
通用的古典實作
既然函式模板不能滿足要求，我們使用類模板不就行了，只要多載了operator()，使用起來也沒多少區別，
所以一個真正通用的古典實作可以寫出下面這樣：
template <typename Tuple, typename Functor, std::size_t Start, std::size_t End>
struct classic_for_each_tuple_helper
{
constexpr void operator()(const Tuple &t, Functor &&f) const
{
f(std::get<Start>(t));
classic_for_each_tuple_helper<Tuple, Functor, Start + 1, End>{}(t, std::forward<Functor>(f));
}
};
我們首先實作了主模板，其中Start和End是tuple開始和結束的索引，每處理一個元素，我們就讓Start加上1，
你可以想一想這里遞回的停止條件是什么，
我們每次給Start遞增1，那么最后我們的Start一定會等于甚至超過End，沒錯，這就是我們的停止條件：
template <typename Tuple, typename Functor, std::size_t End>
struct classic_for_each_tuple_helper<Tuple, Functor, End, End>
{
constexpr void operator()(const Tuple &t, Functor &&f) const
{
f(std::get<End>(t));
}
};
我們沒辦法在模板引數串列里判斷相等，那么最好的解決辦法就是特化出Start和End都一樣的特殊情況，這時候用一樣的值End同時填入主模板的Start和End就行了，
特化的處理也很簡單，我們直接把遞回的陳述句刪了就可以了，
想要使用這個幫助模板還需要一點代碼，因為我可不想每次手動指定一大長串的tuple型別引數，
正好，利用函式模板我們可以自動進行型別推導：
template <typename Tuple, typename Functor>
constexpr void classic_for_each_tuple(const Tuple &t, Functor &&f)
{
classic_for_each_tuple_helper<Tuple, Functor, 0, std::tuple_size_v<Tuple> - 1>{}(t, std::forward<Functor>(f));
}
這樣我們就可以書寫如下的代碼了：
classic_for_each_tuple(std::make_tuple(1, 2, 3, "hello", "world", 3.1415, 2.7183),
[](const auto &element) { /* work */ });
即使是make_tuple生成的臨時物件，我們也可以自動推匯出它的型別，所有粗活累活編譯器都幫我們代勞了，
不過凡事總是有代價的，有得必有失，表面上我們實作了簡單而漂亮的介面，但代價實際上是被轉移到了底層：
$ nm a.out | grep classic_for_each_tuple_helper
00000000000031d6 t _ZNK29classic_for_each_tuple_helperISt5tupleIJiiiPKcS2_ddEEZ4mainEUlRKT_E2_Lm0ELm6EEclERKS3_OS7_
00000000000034f0 t _ZNK29classic_for_each_tuple_helperISt5tupleIJiiiPKcS2_ddEEZ4mainEUlRKT_E2_Lm1ELm6EEclERKS3_OS7_
00000000000036ca t _ZNK29classic_for_each_tuple_helperISt5tupleIJiiiPKcS2_ddEEZ4mainEUlRKT_E2_Lm2ELm6EEclERKS3_OS7_
0000000000003946 t _ZNK29classic_for_each_tuple_helperISt5tupleIJiiiPKcS2_ddEEZ4mainEUlRKT_E2_Lm3ELm6EEclERKS3_OS7_
0000000000003a66 t _ZNK29classic_for_each_tuple_helperISt5tupleIJiiiPKcS2_ddEEZ4mainEUlRKT_E2_Lm4ELm6EEclERKS3_OS7_
0000000000003b94 t _ZNK29classic_for_each_tuple_helperISt5tupleIJiiiPKcS2_ddEEZ4mainEUlRKT_E2_Lm5ELm6EEclERKS3_OS7_
0000000000003c0e t _ZNK29classic_for_each_tuple_helperISt5tupleIJiiiPKcS2_ddEEZ4mainEUlRKT_E2_Lm6ELm6EEclERKS3_OS7_
我們的tuple有6個元素，所以我們生成了6個helper的實體，過多的模板實體會導致代碼膨脹，
模板遞回的另一個缺點是遞回的最大深度有限制，在g++10.2上這個限制是900，也就是說超過900個元素的tuple我們是無法處理的，除非用編譯器的命令列選項更改這一限制，不過通常也沒人會寫出有900多個元素的tuple，
還有一個需要考慮的情況，當我們傳遞了一個空的tuple進去會發生什么呢？
classic_for_each_tuple(std::tuple<>{},
[](const auto &element) { /* work */ });
我們會得到一個編譯錯誤，而我們所期望的是foreach什么也不做，問題發生在std::tuple_size_v<Tuple> - 1，當tuple為空時size為0，而對無符號數的0減去1會導致回環，從而導致get使用的索引的范圍十分巨大，超過了模板遞回深度限制；而更致命的是get一個無效的索引（tuple為空，任何索引都無效）是被static_assert斷言的編譯期錯誤，并且往往會產生一大長串錯誤資訊導致debug困難，
不過別擔心，這是個小問題，解決起來也不麻煩，還記得我們的模板元編程技巧嗎？用多載或特化表示邊界條件：
template <typename Functor>
constexpr void classic_for_each_tuple(const std::tuple<> &, Functor &&)
{
// 什么也不做
}
如此一來空的tuple也不會導致問題了，
雖然有些缺點，還需要工具類模板來實作遍歷，但這是舊時代的c++實作for element in t的唯一選擇，
使用編譯期條件分支
好訊息是現在是現代c++的天下了，我們可以簡化一下代碼，
比如使用c++17提供的編譯期間計算的條件分支，一般形式如下：
if constexpr (編譯期常量運算式) {
work 1
} else {
work 2
}
constexpr if最大的威力在于如果條件運算式為真，那么else里的陳述句根本不會被編譯，反之亦然，當然這得是在模板里，否則else分支的代碼仍然會被編譯器檢查代碼的語法正確性，
沒錯，我們在最開始遇到的問題就是if和else里的陳述句都會被編譯，導致了模板的無限遞回，現在我們可以用constexpr if解決問題了：
template <typename Tuple, typename Functor, int Index>
constexpr void for_each_tuple_impl(Tuple &&t, Functor &&f)
{
if constexpr (Index >= std::tuple_size<std::remove_reference_t<Tuple>>::value) {
return;
} else {
f(std::get<Index>(t));
for_each_tuple_impl<Tuple, Functor, Index+1>(std::forward<Tuple>(t), std::forward<Functor>(f));
}
}
template <typename Tuple, typename Functor>
constexpr void for_each_tuple(Tuple &&t, Functor &&f)
{
for_each_tuple_impl<Tuple, Functor, 0>(std::forward<Tuple>(t), std::forward<Functor>(f));
}
這次當遍歷完最后一個元素后函式會觸發退出遞回的條件，if constexpr會幫我們終止模板的遞回，問題被干凈利落地解決了，
對于空tuple這個方案是如何處理的呢？答案是tuple為空的時候直接達到了impl的退出條件，所以是安全的noop，
雖然代碼被進一步簡化了，但是模板遞回的兩大問題依舊存在，
變長模板引數——錯誤的解法
現代c++有許多簡化模板元編程的利器，如果說前面的constexpr if是編譯期計算和模板不沾邊，那下面要介紹的變長模板引數可就是如假包換的模板技巧了，
顧名思義，變長模板引數可以讓我們在模板引數上指定任意數量的型別/非型別引數：
template <typename... Ts>
class tuple;
上面的就是c++11中新增的tuple的定義，通過變長模板引數使得tuple支持了任意多的型別不同的元素，
想要處理變長模板引數，在c++17之前還是得靠模板遞回，所以我們是不是可以用變長模板引數獲取tuple里每一個元素的型別呢？正好get也可以根據元素的型別來獲取相應的資料，
于是新的實作產生了：
template <typename Tuple, typename Functor, typename First, typename... Ts>
constexpr void for_each_tuple2_impl(const Tuple& t, Functor &&f)
{
f(std::get<First>(t));
for_each_tuple2_impl<Tuple, Functor, Ts...>(t, std::forward<Functor>(f));
}
template <typename Tuple, typename Functor>
constexpr void for_each_tuple2_impl(const Tuple&, Functor &&)
{
return;
}
template <typename Functor, typename... Ts>
constexpr void for_each_tuple2(const std::tuple<Ts...> &t, Functor &&f)
{
for_each_tuple2_impl<std::tuple<Ts...>, Functor, Ts...>(t, std::forward<Functor>(f));
}
代碼有些復雜，我會逐步講解，
首先我們有兩個for_each_tuple2_impl，不過別緊張，因為模板形參不同，所以這是兩個不同的模板（函式模板沒有部分特化），又因為變長引數的實引數量可以為0，為了實體化的時候不會產生歧義，只能讓第二個for_each_tuple2_impl不接受任何額外的模板引數，
接著我們看到for_each_tuple2，它的作用很簡單，通過引數上的std::tuple<Ts...>自動推匯出tuple元素的所有型別，然后存放在Ts里，習慣上我們給變長引數包的名字是以s結尾的，象征引數包里可能有不止一個型別引數，
接下來才是重頭戲，當我們這樣呼叫for_each_tuple2_impl<std::tuple<Ts...>, Functor, Ts...>時，實際上會展開成for_each_tuple2_impl<std::tuple<Type1, Type2, ..., TypeN>, Functor, Type1, Type2, ..., TypeN.>，
對應到我們的template <typename Tuple, typename Functor, typename First, typename... Ts>, First就會是Type1，而其他剩下來的型別又會被收集到for_each_tuple2_impl的Ts里，這樣我們就分離出了第一次個tuple里的元素，
然后我們使用std::get<First>(t)獲取到這個元素，然后遞回重復上述步驟，
Ts的第一個引數會被逐個分離，最后一直到Ts和First都為空，這是遞回就該結束了，所以我們寫出了第二個for_each_tuple2_impl模板來處理這一情況，
因為tuple的型別引數串列的順序和其中包含元素是對應的，所以我們可以實作遍歷，
到目前為止我們的for_each作業得很好，然而當我們傳入了std::make_tuple(1,2,3)，編譯器又一次爆炸了，
好奇的你一定又在思考為什么了，不過這回你應該很快就有了頭緒，tuple<int,int,int>，存在一樣的型別引數，這時候std::get會不會不知道該獲取的是哪個元素呢？
你猜對了，get的檔案里是這么說的Fails to compile unless the tuple has exactly one element of that type.，意思是當某個型別A出現了不止一次時，使用get<A>會導致編譯出錯，
因此這個方案是有重大缺陷的，我們不能保證tuple里總是不同型別的資料，因此這條路走到死胡同里了，
折疊運算式——使用變長模板引數的正確解法
別氣餒，嘗試失敗也是模板元編程的樂趣之一，更何況現代c++里有相當多的實用工具可以加以利用，比如integer_sequence和折疊運算式，
折疊運算式用于按照給定的模式展開變長模板引數包，而integer_sequence則可以用來包含0-N的整數型別非型別模板引數，在我上一篇介紹模板元編程的文章里有介紹，這里不再贅述，
使用integer_sequence可以構建一個包含所有tuple元素索引的編譯期整數常量序列，配合折疊運算式可以把這些索引展開利用，這樣正好可以讓get用上每一個索引：
template <typename Tuple, typename Functor, std::size_t... Is>
constexpr void for_each_tuple3_impl(const Tuple &t, Functor &&f, std::index_sequence<Is...>)
{
// 展開成（f(std::get<0>(t))，f(std::get<1>(t))，...）
(f(std::get<Is>(t)), ...);
}
template <typename Tuple, typename Functor>
constexpr void for_each_tuple3(const Tuple &t, Functor &&f)
{
// std::make_index_sequence<std::tuple_size_v<Tuple>>產生一個index_sequence<0,1,2,..,N>
for_each_tuple3_impl(t, std::forward<Functor>(f), std::make_index_sequence<std::tuple_size_v<Tuple>>());
}
這次不再是模板遞回了，我們生成了所有元素的索引，然后教編譯器硬編碼了所有的get操作，形式上不太像但確確實實完成了遍歷操作，
當然老問題是少不了要問的，tuple為空的時候這個方案能正常作業嗎？
答案是肯定的，標準規定了std::make_index_sequence<0>會生成一個空的序列，而逗號運算子的一元折疊運算式對于空的引數包會安全地回傳void，所以在傳入一個空tuple時我們的函式是noop的，
這種方案簡單粗暴，同時也是三種方法中最直觀的，
而且這個方案不會產生一大堆的模板實體，生成的二進制檔案也是清爽干凈的，同時因為不是遞回，也不會受到遞回深度限制的影響，
這就是現代c++在模板元編程上的威力，
總結
我們一共實作了三種遍歷tuple的方法，從原始到現代，從復雜到簡單，
同時我們還踩掉了一些坑，在今后的開發中只要留意類似的問題也能及時避免了，
當然，我寫的方案仍有很大的提升空間，你可以自己進行嘗試改進，
不過我最想說的還是現代c++真的極大簡化了模板元編程，把模板元編程從一個復雜抽象的黑魔法變成了直觀易于理解的開發技巧，應該有更多的人來體驗使用現代c++的樂趣，c++已經脫胎換骨了，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/270551.html
標籤：C++