聊聊結構化綁定
動機
std::map<K, V>的insert方法返回std::pair<iterator, bool>，兩個元素分別是指向所插入鍵值對的迭代器與指示是否新插入元素的布爾值，而std::map<K, V>::iterator解引用又得到鍵值對std::pair<const K, V>。在一個涉及std::map的算法中，有可能出現大量的first和second，讓人不知所措。
#include <iostream>
#include <map>
int main()
{
typedef std::map<int, int> Map;
Map map;
std::pair<Map::iterator, bool> result = map.insert(Map::value_type(1, 2));
if (result.second)
std::cout << "inserted successfully" << std::endl;
for (Map::iterator iter = map.begin(); iter != map.end(); ++iter)
std::cout << "[" << iter->first << ", " << iter->second << "]" << std::endl;
}C++11 標準庫添加了std::tie，用若干引用構造出一個std::tuple，對它賦以std::tuple對象可以給其中的引用一一賦值（二元std::tuple可以由std::pair構造或賦值）。std::ignore是一個佔位符，所在位置的賦值被忽略。
#include <iostream>
#include <map>
#include <utility>
int main()
{
std::map<int, int> map;
bool inserted;
std::tie(std::ignore, inserted) = map.insert({1, 2});
if (inserted)
std::cout << "inserted successfully" << std::endl;
for (auto&& kv : map)
std::cout << "[" << kv.first << ", " << kv.second << "]" << std::endl;
}但是這種方法仍遠不完美，因爲：
• 變量必須事先單獨聲明，其類型都需顯式表示，無法自動推導；• 對於默認構造函數執行零初始化的類型，零初始化的過程是多餘的；• 也許根本沒有可用的默認構造函數，如std::ofstream。
爲此，C++17 引入了結構化綁定（structured binding）。
#include <iostream>
#include <map>
int main()
{
std::map<int, int> map;
auto&& [iter, inserted] = map.insert({1, 2});
if (inserted)
std::cout << "inserted successfully" << std::endl;
for (auto&& [key, value] : map)
std::cout << "[" << key << ", " << value << "]" << std::endl;
}結構化綁定這一語言特性在提議的階段曾被稱爲分解聲明（decomposition declaration），後來又被改回結構化綁定。這個名字想強調的是，結構化綁定的意義重在綁定而非聲明。
語法
結構化綁定有三種語法：
attr(optional) cv-auto ref-operator(optional) [ identifier-list ] = expression;
attr(optional) cv-auto ref-operator(optional) [ identifier-list ] { expression };
attr(optional) cv-auto ref-operator(optional) [ identifier-list ] ( expression );其中，attr(optional)爲可選的 attributes，cv-auto爲可能有const或volatile修飾的auto，ref-operator(optional)爲可選的&或&&，identifier-list爲逗號分隔的標識符，expression爲單個表達式。
另外再定義initializer爲= expression、{ expression }或( expression )，換言之上面三種語法有統一的形式attr(optional) cv-auto ref-operator(optional) [ identifier-list ] initializer;。
整個語句是一個結構化綁定聲明，標識符也稱爲結構化綁定（structured bindings），不過兩處 “binding” 的詞性不同。
順帶一提，C++20 中volatile的許多用法都被廢棄了。
行爲
結構化綁定有三類行爲，與上面的三種語法之間沒有對應關係。
第一種情況，expression是數組，identifier-list的長度必須與數組長度相等。
第二種情況，對於expression的類型E，std::tuple_size<E>是一個完整類型，則稱E爲類元組（tuple-like）類型。在 STL 中，std::array、std::pair和std::tuple都是這樣的類型。此時，identifier-list的長度必須與std::tuple_size<E>::value相等，每個標識符的類型都通過std::tuple_element推導出（具體見後文），用成員get<I>()或get<I>(e)初始化。顯然，這些標準庫設施是與語言核心綁定的。
第三種情況，E是非union類類型，綁定非靜態數據成員。所有非靜態數據成員都必須是public訪問屬性，全部在E中，或全部在E的一個基類中（即不能分散在多個類中）。identifier-list按照類中非靜態數據成員的聲明順序綁定，數量相等。
應用
結構化綁定擅長處理純數據類型，包括自定義類型與std::tuple等，給實例的每一個字段分配一個變量名：
#include <iostream>
struct Point
{
double x, y;
};
Point midpoint(const Point& p1, const Point& p2)
{
return { (p1.x + p2.x) / 2, (p1.y + p2.y) / 2 };
}
int main()
{
Point p1{ 1, 2 };
Point p2{ 3, 4 };
auto [x, y] = midpoint(p1, p2);
std::cout << "(" << x << ", " << y << ")" << std::endl;
}配合其他語法糖，現代 C++ 代碼可以很優雅：
#include <iostream>
#include <map>
int main()
{
std::map<int, int> map;
if (auto&& [iter, inserted] = map.insert({ 1, 2 }); inserted)
std::cout << "inserted successfully" << std::endl;
for (auto&& [key, value] : map)
std::cout << "[" << key << ", " << value << "]" << std::endl;
}利用結構化綁定在類元組類型上的行爲，我們可以改變數據類型的結構化綁定細節，包括類型轉換、是否拷貝等：
#include <iostream>
#include <string>
#include <utility>
class Transcript { /* ... */ };
class Student
{
public:
const char* name;
Transcript score;
std::string getName() const { return name; }
const Transcript& getScore() const { return score; }
template<std::size_t I>
decltype(auto) get() const
{
if constexpr (I == 0)
return getName();
else if constexpr (I == 1)
return getScore();
else
static_assert(I < 2);
}
};
namespace std
{
template<>
struct tuple_size<Student>
: std::integral_constant<std::size_t, 2> { };
template<>
struct tuple_element<0, Student> { using type = decltype(std::declval<Student>().getName()); };
template<>
struct tuple_element<1, Student> { using type = decltype(std::declval<Student>().getScore()); };
}
int main()
{
std::cout << std::boolalpha;
Student s{ "Jerry", {} };
const auto& [name, score] = s;
std::cout << name << std::endl;
std::cout << (&score == &s.score) << std::endl;
}Student是一個數據類型，有兩個字段name和score。name是一個 C 風格字符串，它大概是從 C 代碼繼承來的，我希望客戶能用上 C++ 風格的std::string；score屬於Transcript類型，表示學生的成績單，這個結構比較大，我希望能傳遞const引用以避免不必要的拷貝。爲此，我寫明瞭三要素：std::tuple_size、std::tuple_element和get。這種機制給了結構化綁定很強的靈活性。
細節
#include <iostream>
#include <utility>
#include <tuple>
int main()
{
std::pair pair{ 1, 2.0 };
int number = 3;
std::tuple<int&> tuple(number);
const auto& [i, f] = pair;
//i = 4; // error
const auto& [ri] = tuple;
ri = 5;
}如果結構化綁定i被聲明爲const auto&，對應的類型爲int，那麼它應該是個const int&吧？i = 4;出錯了，看起來正是如此。但是如何解釋ri = 5;是合法的呢？
這個問題需要系統地從頭談起。先引入一個名字e，E爲其類型：
• 當expression是數組類型A，且ref-operator不存在時，E爲cv A，每個元素由expression中的對應元素拷貝（= expression）或直接初始化（{ expression }或( expression )；• 否則，相當於定義e爲attr cv-auto ref-operator e initializer;。
也就是說，方括號前面的修飾符都是作用於e的，而不是那些新聲明的變量。至於爲什麼第一條會獨立出來，這是因爲在標準 C++ 中第二條的形式不能用於數組拷貝。
然後分三種情況討論：
• 數組情形，E爲T的數組類型，則每個結構化綁定都是指向e數組中元素的左值；被引類型（referenced type）爲T；——結構化綁定是左值，不是左值引用：int array[2]{ 1, 2 }; auto& [i, j] = array; static_assert(!std::is_reference_v<decltype(i)>);；• 類元組情形，如果e是左值引用，則e是左值（lvalue），否則是消亡值（xvalue）；記Ti爲std::tuple_element<i, E>::type，則結構化綁定vi的類型是Ti的引用；當get返回左值引用時是左值引用，否則是右值引用；被引類型爲Ti；——decltype對結構化綁定有特殊處理，產生被引類型，在類元組情形下結構化綁定的類型與被引類型是不同的；• 數據成員情形，與數組類似，設數據成員mi被聲明爲Ti類型，則結構化綁定的類型是指向cv Ti的左值（同樣不是左值引用）；被引類型爲cv Ti。
至此，我想 “結構化綁定” 的意義已經明確了：標識符總是綁定一個對象，該對象是另一個對象的成員（或數組元素），後者或是拷貝或是引用（引用不是對象，意會即可）。與引用類似，結構化綁定都是既有對象的別名（這個對象可能是隱式的）；與引用不同，結構化綁定不一定是引用類型。
（不理解的話可以參考 N4659 11.5 節，儘管你很可能會更加看不懂……）
現在可以解釋ri非const的現象了：編譯器先創建了變量const auto& e = tuple;，E爲const std::tuple<int&>&，std::tuple_element<0, E>::type爲int&，std::get<0>(e)同樣返回int&，故ri爲int&類型。
在面向底層的 C++ 編程中常用union和位域（bit field），結構化綁定支持這樣的數據成員。如果類有union類型成員，它必須是命名的，綁定的標識符的類型爲該union類型的左值；如果有未命名的union成員，則這個類不能用於結構化綁定。
C++ 中不存在位域的指針和引用，但結構化綁定可以是指向位域的左值：
#include <iostream>
struct BitField
{
int f1 : 4;
int f2 : 4;
int f3 : 4;
};
int main()
{
BitField b{ 1, 2, 3 };
auto& [f1, f2, f3] = b;
f2 = 4;
auto print = [&] { std::cout << b.f1 << " " << b.f2 << " " << b.f3 << std::endl; };
print();
f2 = 21;
print();
}程序輸出：
1 4 3
1 5 3f2的功能就像位域的引用一樣，既能寫回原值，又不會超出位域的範圍。
還有一些語法細節，比如get的名字查找、std::tuple_size<E>沒有value、explicit拷貝構造函數等，除非是深挖語法的 language lawyer，在實際開發中不必糾結（上面這一堆已經可以算 language lawyer 了吧）。
侷限
以上代碼示例應該已經囊括了所有類型的結構化綁定應用，你能想象到的其他語法都是錯的，包括但不限於：
• 用std::initializer_list<T>初始化；因爲std::initializer_list<T>的長度是動態的，但結構化綁定的標識符數量是靜態的。• 用列表初始化——auto [x,y,z] = {1, "xyzzy"s, 3.14159};；這相當於聲明瞭三個變量，但結構化綁定的意圖在於綁定而非聲明。• 不聲明而直接綁定——[iter, success] = mymap.insert(value);；這相當於用std::tie，所以請繼續用std::tie。另外，由[開始可能與 attributes 混淆，給編譯器和編譯器設計者帶來壓力。• 指明結構化綁定的修飾符——auto [& x, const y, const& z] = f();；同樣是脫離了結構化綁定的意圖。如果需要這樣的功能，或者一個個定義變量，或者手動寫上三要素。• 指明結構化綁定的類型——SomeClass [x, y] = f();或auto [x, std::string y] = f();；第一種可用auto [x, y] = SomeClass{ f() };代替；第二種同上一條。• 顯式忽略一個結構化綁定——auto [x, std::ignore, z] = f();；消除編譯器警告是一個理由，但是auto [x, y, z] = f(); (void)y;亦可。這還涉及一些語言問題，請移步 P0144R2 3.8 節。• 標識符嵌套——std::tuple<T1, std::pair<T2, T3>, T4> f(); auto [ w, [x, y], z ] = f();；多寫一行吧。[同樣可能與 attributes 混淆。
以上語法都沒有納入 C++20 標準，不過可能在將來成爲 C++ 語法的擴展。
延伸
C++17 的新特性不是孤立的，與結構化綁定相關的有：
• 類模板參數推導（class template argument deduction，CTAD），由構造函數參數推導類模板參數；• 拷貝省略（copy elision），保證 NRV（named return value）優化；•constexpr if，簡化泛型代碼，消除部分 SFINAE；• 帶初始化的條件分支語句：語法糖，使代碼更加優雅。
你好，我是雨樂，從業十二年有餘，歷經過傳統行業網絡研發、互聯網推薦引擎研發，目前在廣告行業從業 8 年。目前任職某互聯網公司高級技術專家一職，負責廣告引擎的架構和研發。
本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/AqFVkuQp3K51_DaJI-8hWg