Chapter1 结构化绑定

结构化绑定允许你用一个对象的元素或成员同时实例化多个实体。

例如，假设你定义了一个有两个不同成员的结构体：

  1. struct MyStruct {
  2.     int i = 0;
  3.     std::string s;
  4. };
  6. MyStruct ms;

你可以通过如下的声明直接把该结构体的两个成员绑定到新的变量名：

  1. auto [u, v] = ms;

这里，变量u和v的声明方式称为 结构化绑定 。 某种程度上可以说它们 分解了(Decompose) 用来初始化的对象（有些观点称它们为 分解声明(Decomposing Declaration) ）。

下列每一种声明方式都是支持的：

  1. auto [u2, v2] {ms};
  2. auto [u3, v3] (ms);

结构化绑定对于返回结构体或者数组的函数来说非常有用。例如，考虑一个返回结构体的函数：

  1. MyStruct getStruct() {
  2.     return MyStruct{42, "hello"};
  3. }

你可以直接把返回的数据成员赋值给两个新的局部变量：

  1. auto [id, val] = getStruct();  // id和val分别是返回结构体的i和s成员

这个例子中，id和val分别是返回结构体中的i和s成员。 它们的类型分别是int和std::string，可以被当作两个不同的对象来使用：

  1. if (id > 30) {
  2.     std::cout << val;
  3. }

这么做的好处是可以直接访问成员。另外，把值绑定到能体现语义的变量名上，可以使代码的可读性更强。

下面的代码演示了使用结构化绑定带来的显著改进。 在不使用结构化绑定的情况下遍历std::map<>的元素需要这么写：

  1. for (const auto& elem : mymap) {
  2.     std::cout << elem.first << ": " << elem.second << '\n';
  3. }

map的元素的类型是key和value组成的std::pair类型， 该类型的两个成员分别是first和second。 在上边的例子中我们必须使用成员的名字来访问key和value，而通过使用结构化绑定， 能大大提升代码的可读性：

  1. for (const auto& [key, val] : mymap) {
  2.     std::cout << key << ": " << val << '\n';
  3. }

上面的例子中我们可以使用准确体现语义的变量名直接访问每个元素的key和value成员。

1.1 细说结构化绑定

为了理解结构化绑定，必须意识到这里面其实有一个隐藏的匿名对象。 结构化绑定时引入的新变量名其实都指向这个匿名对象的成员/元素。

绑定到一个匿名实体

如下初始化的精确行为：

  1. auto [u, v] = ms;

等价于我们用ms初始化了一个新的实体e， 并且让结构化绑定中的u和v变成e的成员的别名，类似于如下定义：

  1. auto e = ms;
  2. aliasname u = e.i;
  3. aliasname v = e.s;

这意味着u和v仅仅是ms的一份本地拷贝的成员的别名。 然而，我们没有为e声明一个名称，因此我们不能直接访问这个匿名对象。 注意u和v并不是e.i和e.s的引用（而是它们的别名）。 decltype(u)的结果是成员i的类型， declytpe(v)的结果是成员s的类型。 因此：

  1. std::cout << u << ' ' << v << '\n';

会打印出e.i和e.s（分别是ms.i和ms.s的拷贝）。

e的生命周期和结构化绑定的生命周期相同，当结构化绑定离开作用域时e也会被自动销毁。 另外，除非使用了引用，否则修改用于初始化的变量并不会影响结构化绑定引入的变量（反过来也一样）：

  1. MyStruct ms{42, "hello"};
  2. auto [u, v] = ms;
  3. ms.i = 77;
  4. std::cout << u;     // 打印出42
  5. u = 99;
  6. std::cout << ms.i;  // 打印出77

在这个例子中u和ms.i有不同的内存地址。

当使用结构化绑定来绑定返回值时，规则是相同的。如下初始化

  1. auto [u, v] = getStruct();

的行为等价于我们用getStruct()的返回值初始化了一个新的实体e， 之后结构化绑定的u和v变成了e的两个成员的别名，类似于如下定义：

  1. auto e = getStruct();
  2. aliasname u = e.i;
  3. aliasname v = e.s;

也就是说，结构化绑定绑定到了一个 新的 实体e上，而不是直接绑定到了返回值上。

匿名实体e同样遵循通常的内存对齐规则，结构化绑定的每一个变量都会根据相应成员的类型进行对齐。

使用修饰符

我们可以在结构化绑定中使用修饰符，例如const和引用，这些修饰符会作用在匿名实体e上。 通常情况下，作用在匿名实体上和作用在结构化绑定的变量上的效果是一样的，但有些时候又是不同的（见下文）。

例如，我们可以把一个结构化绑定声明为const引用：

  1. const auto& [u, v] = ms;    // 引用，因此u/v指向ms.i/ms.s

这里，匿名实体被声明为const引用， 而u和v分别是这个引用的成员i和s的别名。 因此，对ms的成员的修改会影响到u和v的值：

  1. ms.i = 77;          // 影响u的值
  2. std::cout << u;     // 打印出77

如果声明为非const引用，你甚至可以间接地修改用于初始化的对象的成员：

  1. MyStruct ms{ 42, "hello" };
  2. auto& [u, v] = ms;      // 被初始化的实体是ms的引用
  3. ms.i = 77;              // 影响到u的值
  4. std::cout << u;         // 打印出77
  5. u = 99;                 // 修改了ms.i
  6. std::cout << ms.i;      // 打印出99

如果一个结构化绑定是引用类型，而且是对一个临时对象的引用，那么和往常一样， 临时对象的生命周期会被延长到结构化绑定的生命周期：

  1. MyStruct getStruct();
  2. ...
  3. const auto& [a, b] = getStruct();
  4. std::cout << "a: " << a << '\n';    // OK

修饰符并不是作用在结构化绑定引入的变量上

修饰符会作用在新的匿名实体上，而不是结构化绑定引入的新的变量名上。事实上，如下代码中：

  1. const auto& [u, v] = ms;    // 引用，因此u/v指向ms.i/ms.s

u和v都 不是 引用，只有匿名实体e是一个引用。 u和v分别是ms对应的成员的类型， 只不过变成了const的（因为你不能修改常量引用的成员）。 根据我们的推导，decltype(u)是const int， decltype(v)是const std::string。

当指明对齐时也是类似：

  1. alignas(16) auto [u, v] = ms;   // 对齐匿名实体，而不是v

这里，我们对齐了匿名实体而不是u和v。 这意味着u作为第一个成员会按照16字节对齐，但v不会。

因此，即使使用了auto结构化绑定也不会发生 类型退化(decay) 。 例如，如果我们有一个原生数组组成的结构体：

  1. struct S {
  2.     const char x[6];
  3.     const char y[3];
  4. };

那么如下声明之后：

  1. S s1{};
  2. auto [a, b] = s1;    // a和b的类型是结构体成员的精确类型

这里a的类型仍然是const char[6]。 再次强调，auto关键字应用在匿名实体上，这里匿名实体整体并不会发生类型退化。 这和用auto初始化新对象不同，如下代码中会发生类型退化：

  1. auto a2 = a;    // a2的类型是a的退化类型

move语义

move语义也遵循之前介绍的规则，如下声明：

  1. MyStruct ms = {42, "Jim"};
  2. auto&& [v, n] = std::move(ms);     // 匿名实体是ms的右值引用

这里v和n指向的匿名实体是ms的右值引用， 同时ms仍持有值：

  1. std::cout << "ms.s: " << ms.s << '\n';  // 打印出"Jim"

然而，你可以对指向ms.s的n进行移动赋值：

  1. std::string s = std::move(n);           // 把ms.s移动到s
  2. std::cout << "ms.s: " << ms.s << '\n';  // 打印出未定义的值
  3. std::cout << "n:    " << n << '\n';     // 打印出未定义的值
  4. std::cout << "s:    " << s << '\n';     // 打印出"Jim"

像通常一样，值被移动走的对象处于一个值未定义但却有效的状态。因此可以打印它们的值， 但不要对打印出的值做任何假设。

上面的例子和直接用ms被移动走的值进行结构化绑定有些不同：

  1. MyStruct ms = {42, "Jim"};
  2. auto [v, n] = std::move(ms);    // 新的匿名实体持有从ms处移动走的值

这里新的匿名实体是用ms被移动走的值来初始化的。因此，ms已经失去了值：

  1. std::cout << "ms.s: " << ms.s << '\n';  // 打印出未定义的值
  2. std::cout << "n:    " << n << '\n';     // 打印出"Jim"

你可以继续用n进行移动赋值或者给n赋予新值，但已经不会再影响到ms.s了：

  1. std::string s = std::move(n);   // 把n移动到s
  2. n = "Lara";
  3. std::cout << "ms.s: " << ms.s << '\n';  // 打印出未定义的值
  4. std::cout << "n:    " << n << '\n';     // 打印出"Lara"
  5. std::cout << "s:    " << s << '\n';     // 打印出"Jim"

1.2 结构化绑定的适用场景

理论上讲，结构化绑定适用于任何有public数据成员的结构体、 C风格数组和“类似元组(tuple-like)的对象”：

  • 对于所有非静态数据成员都是public的 结构体和类 ， 你可以把每一个成员绑定到一个新的变量名上。
  • 对于 原生数组 ，你可以把数组的每一个元素都绑定到新的变量名上。

  • 对于任何类型，你可以使用 tuple-like API 来绑定新的名称， 无论这套API是如何定义“元素”的。对于一个类型 type 这套API需要如下的组件：

    • std::tuple_size<type>::value要返回元素的数量。
    • std::tuple_element<idx, type>::type 要返回第idx个元素的类型。
    • 一个全局或成员函数get<idx>()要返回第idx个元素的值。

标准库类型std::pair<>、std::tuple<>、std::array<> 就是提供了这些API的例子。 如果结构体和类提供了tuple-like API，那么将会使用这些API进行绑定，而不是直接绑定数据成员。

在任何情况下，结构化绑定中声明的变量名的数量都必须和元素或数据成员的数量相同。 你不能跳过某个元素，也不能重复使用变量名。然而，你可以使用非常短的名称例如'_' （有的程序员喜欢这个名字，有的讨厌它，但注意全局命名空间不允许使用它）， 但这个名字在同一个作用域只能使用一次：

  1. auto [_, val1] = getStruct();   // OK
  2. auto [_, val2] = getStruct();   // ERROR:变量名_已经被使用过

目前还不支持嵌套化的结构化绑定。

下一小节将详细讨论结构化绑定的使用。

1.2.1 结构体和类

上面几节里已经介绍了对只有public成员的结构体和类使用结构化绑定的方法， 一个典型的应用是直接对包含多个数据的返回值使用结构化绑定 （例如，见以节点句柄为参数的insert()）。 然而有一些边缘情况需要注意。

注意要使用结构化绑定需要继承时遵循一定的规则。所有的非静态数据成员必须在同一个类中定义 （也就是说，这些成员要么是全部直接来自于最终的类，要么是全部来自同一个父类）：

  1. struct B {
  2.     int a = 1;
  3.     int b = 2;
  4. };
  6. struct D1 : B {
  7. };
  8. auto [x, y] = D1{};     // OK
  10. struct D2 : B {
  11.     int c = 3;
  12. };
  13. auto [i, j, k] = D2{};  // 编译期ERROR

注意只有当public成员的顺序保证是固定的时候你才应该使用结构化绑定。 否则如果B中的int a和int b的顺序发生了变化， x和y的值也会随之变化。为了保证固定的顺序， C++17为一些标准库结构体（例如insert_return_type） 定义了成员顺序。

联合还不支持使用结构化绑定。

1.2.2 原生数组

下面的代码用C风格数组的两个元素初始化了x和y：

  1. int arr[] = { 47, 11 };
  2. auto [x, y] = arr;  // x和y是arr中的int元素的拷贝
  3. auto [z] = arr;     // ERROR：元素的数量不匹配

注意这是C++中少数几种原生数组会按值拷贝的场景之一。

只有当数组的长度已知时才可以使用结构化绑定。 数组作为按值传入的参数时不能使用结构化绑定，因为数组会 退化(decay) 为相应的指针类型。

注意C++允许通过引用来返回带有大小信息的数组，结构化绑定可以应用于返回这种数组的函数：

  1. auto getArr() -> int(&)[2]; // getArr()返回一个原生int数组的引用
  2. ...
  3. auto [x, y] = getArr();     // x和y是返回的数组中的int元素的拷贝

你也可以对std::array使用结构化绑定，这是通过下一节要讲述的tuple-like API来实现的。

1.2.3 std::pair, std::tuple和std::array

结构化绑定机制是可拓展的，你可以为任何类型添加对结构化绑定的支持。 标准库中就为std::pair<>、std::tuple<>、 std::array<>添加了支持。

std::array

例如，下面的代码为getArray()返回的std::array<>中的四个元素绑定了 新的变量名a，b，c，d：

  1. std::array<int, 4> getArray();
  2. ...
  3. auto [a, b, c, d] = getArray(); // a,b,c,d是返回值的拷贝中的四个元素的别名

这里a，b，c，d被绑定到getArray()返回的 std::array类型的元素上。

使用非临时变量的non-const引用进行绑定，还可以进行修改操作。例如：

  1. std::array<int, 4> stdarr { 1, 2, 3, 4 };
  2. ...
  3. auto& [a, b, c, d] = stdarr;
  4. a += 10;    // OK：修改了stdarr[0]
  6. const auto& [e, f, g, h] = stdarr;
  7. e += 10;    // ERROR：引用指向常量对象
  9. auto&& [i, j, k, l] = stdarr;
  10. i += 10;    // OK：修改了stdarr[0]
  12. auto [m, n, o, p] = stdarr;
  13. m += 10;    // OK：但是修改的是stdarr[0]的拷贝

然而像往常一样，我们不能用临时对象(prvalue)初始化一个非 const引用：

  1. auto& [a, b, c, d] = getArray();    // ERROR

std::tuple

下面的代码将a，b，c初始化为getTuple()返回的 std::tuple<>的拷贝的三个元素的别名：

  1. std::tuple<char, float, std::string> getTuple();
  2. ...
  3. auto [a, b, c] = getTuple();    // a,b,c的类型和值与返回的tuple中相应的成员相同

其中a的类型是char，b的类型是float， c的类型是std::string。

std::pair

作为另一个例子，考虑如下对关联/无序容器的insert()成员的返回值进行处理的代码：

  1. std::map<std::string, int> coll;
  2. auto ret = coll.insert({"new", 42});
  3. if (!ret.second) {
  4.     // 如果插入失败，使用ret.first处理错误
  5.     ...
  6. }

通过使用结构化绑定来代替返回的std::pair<>对象的first和 second成员，代码的可读性大大增强：

  1. auto [pos, ok] = coll.insert({"new", 42});
  2. if (!ok) {
  3.     // 如果插入失败，用pos处理错误
  4.     ...
  5. }

注意在这种场景中，C++17中提供了一种使用带初始化的if语句 来进行改进的方法。

为pair和tuple的结构化绑定赋予新值

在声明了一个结构化绑定之后，你通常不能同时修改所有绑定的变量， 因为结构化绑定只能一起声明但不能一起使用。然而，如果被赋的值可以赋给一个std::pair<>或std::tuple<> ，你可以使用std::tie() 把值一起赋给所有变量。例如：

  1. std::tuple<char, float, std::string> getTuple();
  2. ...
  3. auto [a, b, c] = getTuple();    // a,b,c的类型和值与返回的tuple相同
  4. ...
  5. std::tie(a, b, c) = getTuple(); // a,b,c的值变为新返回的tuple的值

这种方法可以被用来处理返回多个值的循环，例如在循环中使用搜索器：

  1. std::boyer_moore_searcher bmsearch{sub.begin(), sub.end()};
  2. for (auto [beg, end] = bmsearch(text.begin(), text.end());
  3.     beg != text.end();
  4.     std::tie(beg, end) = bmsearch(end, text.end())) {
  5.     ...
  6. }

1.3 为结构化绑定提供Tuple-Like API

你可以通过提供 tuple-like API 为任何类型添加对结构化绑定的支持， 就像标准库为std::pair<>、std::tuple<>、std::array<>做的一样：

支持只读结构化绑定

下面的例子演示了怎么为一个类型Customer添加结构化绑定支持， 类的定义如下：

  1. #include <string>
  2. #include <utility>  // for std::move()
  4. class Customer {
  5. private:
  6.     std::string first;
  7.     std::string last;
  8.     long val;
  9. public:
  10.     Customer (std::string f, std::string l, long v)
  11.         : first{std::move(f)}, last{std::move(l)}, val{v} {
  12.     }
  13.     std::string getFirst() const {
  14.         return first;
  15.     }
  16.     std::string getLast() const {
  17.         return last;
  18.     }
  19.     long getValue() const {
  20.         return val;
  21.     }
  22. };

我们可以用如下代码添加tuple-like API：

  1. #include "customer1.hpp"
  2. #include <utility>  // for tuple-like API
  4. // 为类Customer提供tuple-like API来支持结构化绑定：
  5. template<>
  6. struct std::tuple_size<Customer> {
  7.     static constexpr int value = 3; // 有三个属性
  8. };
  10. template<>
  11. struct std::tuple_element<2, Customer> {
  12.     using type = long;              // 最后一个属性的类型是long
  13. };
  14. template<std::size_t Idx>
  15. struct std::tuple_element<Idx, Customer> {
  16.     using type = std::string;       // 其他的属性都是string
  17. };
  19. // 定义特化的getter：
  20. template<std::size_t> auto get(const Customer& c);
  21. template<> auto get<0>(const Customer& c) { return c.getFirst(); }
  22. template<> auto get<1>(const Customer& c) { return c.getLast(); }
  23. template<> auto get<2>(const Customer& c) { return c.getValue(); }

这里，我们为顾客的三个属性定义了tuple-like API，并映射到三个getter（也可以自定义其他映射）：

  • 顾客的名（first name）是std::string类型
  • 顾客的姓（last name）是std::string类型
  • 顾客的消费金额是long类型

属性的数量被定义为std::tuple_size模板函数对Customer类型的特化版本：

  1. template<>
  2. struct std::tuple_size<Customer> {
  3.     static constexpr int value = 3; // 我们有3个属性
  4. };

属性的类型被定义为std::tuple_element的特化版本：

  1. template<>
  2. struct std::tuple_element<2, Customer> {
  3.     using type = long;              // 最后一个属性的类型是long
  4. };
  5. template<std::size_t Idx>
  6. struct std::tuple_element<Idx, Customer> {
  7.     using type = std::string;       // 其他的属性都是string
  8. };

第三个属性的类型是long，被定义为Idx为2时的完全特化版本。 其他的属性类型都是std::string，被定义为部分特化版本（优先级比全特化版本低）。 这里声明的类型就是结构化绑定时decltype返回的类型。

最后，我们在和类Customer同级的命名空间中定义了函数get<>()的 重载版本作为getter：

  1. template<std::size_t> auto get(const Customer& c);
  2. template<> auto get<0>(const Customer& c) { return c.getFirst(); }
  3. template<> auto get<1>(const Customer& c) { return c.getLast(); }
  4. template<> auto get<2>(const Customer& c) { return c.getValue(); }

在这种情况下，我们有一个主函数模板的声明和针对所有情况的全特化版本。

注意函数模板的全特化版本必须使用和声明时相同的类型（包括返回值类型都必须完全相同）。 这是因为我们只是提供特化版本的“实现”，而不是新的声明。下面的代码将不能通过编译：

  1. template<std::size_t> auto get(const Customer& c);
  2. template<> std::string get<0>(const Customer& c) { return c.getFirst(); }
  3. template<> std::string get<1>(const Customer& c) { return c.getLast(); }
  4. template<> long get<2>(const Customer& c) { return c.getValue(); }

通过使用新的编译期if语句特性，我们可以把get<>()函数的实现

合并到一个函数里：

  1. template<std::size_t I> auto get(const Customer& c) {
  2.     static_assert(I < 3);
  3.     if constexpr (I == 0) {
  4.         return c.getFirst();
  5.     }
  6.     else if constexpr (I == 1) {
  7.         return c.getLast();
  8.     }
  9.     else {  // I == 2
  10.         return c.getValue();
  11.     }
  12. }

有了这个API，我们就可以为类型Customer使用结构化绑定：

  1. #include "structbind1.hpp"
  2. #include <iostream>
  4. int main()
  5. {
  6.     Customer c{"Tim", "Starr", 42};
  8.     auto [f, l, v] = c;
  10.     std::cout << "f/l/v:    " << f << ' ' << l << ' ' << v << '\n';
  12.     // 修改结构化绑定的变量
  13.     std::string s{std::move(f)};
  14.     l = "Waters";
  15.     v += 10;
  16.     std::cout << "f/l/v:    " << f << ' ' << l << ' ' << v << '\n';
  17.     std::cout << "c:        " << c.getFirst() << ' '
  18.         << c.getLast() << ' ' << c.getValue() << '\n';
  19.     std::cout << "s:        " << s << '\n';
  20. }

如下初始化之后：

  1. auto [f, l, v] = c;

像之前的例子一样，Customer c被拷贝到一个匿名实体。 当结构化绑定离开作用域时匿名实体也被销毁。

另外，对于每一个绑定f、l、v， 它们对应的get<>()函数都会被调用。 因为定义的get<>函数返回类型是auto，所以这3个getter会返回成员的拷贝， 这意味着结构化绑定的变量的地址不同于c 中成员的地址。 因此，修改c的值并不会影响绑定变量（反之亦然）。

使用结构化绑定等同于使用get<>()函数的返回值，因此：

  1. std::cout << "f/l/v:    " << f << ' ' << l << ' ' << v << '\n';

只是简单的输出变量的值（并不会再次调用getter函数）。另外

  1. std::string s{std::move(f)};
  2. l = "Waters";
  3. v += 10;
  4. std::cout << "f/l/v:    " << f << ' ' << l << ' ' << v << '\n';

这段代码修改了绑定变量的值。

因此，这段程序通常有如下输出：

  1. f/l/v:    Tim Starr 42
  2. f/l/v:     Waters 52
  3. c:        Tim Starr 42
  4. s:        Tim

第二行的输出依赖于被move的string的值，一般情况下是空串，但也有可能是其他有效的值。

你也可以在迭代一个元素类型为Customer的vector时使用结构化绑定：

  1. std::vector<Customer> coll;
  2. ...
  3. for (const auto& [first, last, val] : coll) {
  4.     std::cout << first << ' ' << last << ": " << val << '\n';
  5. }

在这个循环中，因为使用了const auto&所以不会有Customer被拷贝。 然而，结构化绑定的变量初始化时会调用get<>()函数返回姓和名的拷贝。 之后，循环体内的输出语句中使用了结构化绑定的变量，不需要再次调用getter。 最后在每一次迭代结束的时候，拷贝的字符串会被销毁。

注意对绑定变量使用decltype会推导出变量自身的类型， 不会受到匿名实体的类型修饰符的影响。也就是说这里decltype(first)的类型是 const std::string而不是引用。

支持可写结构化绑定

实现tuple-like API时可以返回non-const引用，这样结构化绑定就带有写权限。 设想类Customer提供了读写成员的API：

  1. #include <string>
  2. #include <utility>  // for std::move()
  4. class Customer {
  5. private:
  6.     std::string first;
  7.     std::string last;
  8.     long val;
  9. public:
  10.     Customer (std::string f, std::string l, long v)
  11.         : first{std::move(f)}, last{std::move(l)}, val{v} {
  12.     }
  13.     const std::string& firstname() const {
  14.         return first;
  15.     }
  16.     std::string& firstname() {
  17.         return first;
  18.     }
  19.     const std::string& lastname() const {
  20.         return last;
  21.     }
  22.     long value() const {
  23.         return val;
  24.     }
  25.     long& value() {
  26.         return val;
  27.     }
  28. };

为了支持读写，我们需要为常量和非常量引用定义重载的getter：

  1. #include "customer2.hpp"
  2. #include <utility>  // for tuple-like API
  4. // 为类Customer提供tuple-like API来支持结构化绑定：
  5. template<>
  6. struct std::tuple_size<Customer> {
  7.     static constexpr int value = 3; // 有3个属性
  8. };
  10. template<>
  11. struct std::tuple_element<2, Customer> {
  12.     using type = long;              // 最后一个属性的类型是long
  13. }
  14. template<std::size_t Idx>
  15. struct std::tuple_element<Idx, Customer> {
  16.     using type = std::string;       // 其他的属性是string
  17. }
  19. // 定义特化的getter：
  20. template<std::size_t I> decltype(auto) get(Customer& c) {
  21.     static_assert(I < 3);
  22.     if constexpr (I == 0) {
  23.         return c.firstname();
  24.     }
  25.     else if constexpr (I == 1) {
  26.         return c.lastname();
  27.     }
  28.     else {  // I == 2
  29.         return c.value();
  30.     }
  31. }
  32. template<std::size_t I> decltype(auto) get(const Customer& c) {
  33.     static_assert(I < 3);
  34.     if constexpr (I == 0) {
  35.         return c.firstname();
  36.     }
  37.     else if constexpr (I == 1) {
  38.         return c.lastname();
  39.     }
  40.     else {  // I == 2
  41.         return c.value();
  42.     }
  43. }
  44. template<std::size_t I> decltype(auto) get(Customer&& c) {
  45.     static_assert(I < 3);
  46.     if constexpr (I == 0) {
  47.         return std::move(c.firstname());
  48.     }
  49.     else if constexpr (I == 1) {
  50.         return std::move(c.lastname());
  51.     }
  52.     else {  // I == 2
  53.         return c.value();
  54.     }
  55. }

注意你必须提供这3个版本的特化来处理常量对象、非常量对象、可移动对象 。 为了能返回引用，你应该使用decltype(auto)作为返回类型 。

这里我们又一次使用了编译期if语句特性， 这可以让我们的getter的实现变得更加简单。如果没有这个特性，我们必须写出所有的全特化版本，例如：

  1. template<std::size_t> decltype(auto) get(const Customer& c);
  2. template<std::size_t> decltype(auto) get(Customer& c);
  3. template<std::size_t> decltype(auto) get(Customer&& c);
  4. template<> decltype(auto) get<0>(const Customer& c) { return c.firstname(); }
  5. template<> decltype(auto) get<0>(Customer& c) { return c.firstname(); }
  6. template<> decltype(auto) get<0>(Customer&& c) { return c.firstname(); }
  7. template<> decltype(auto) get<1>(const Customer& c) { return c.lastname(); }
  8. template<> decltype(auto) get<1>(Customer& c) { return c.lastname(); }
  9. ...

再次强调，主函数模板声明必须和全特化版本拥有完全相同的签名（包括返回值）。 下面的代码不能通过编译：

  1. template<std::size_t> decltype(auto) get(Customer& c);
  2. template<> std::string& get<0>(Customer& c) { return c.firstname(); }
  3. template<> std::string& get<1>(Customer& c) { return c.lastname(); }
  4. template<> long& get<2>(Customer& c) { return c.value(); }

你现在可以对Customer类使用结构化绑定了，并且还能通过绑定修改成员的值：

  1. #include "structbind2.hpp"
  2. #include <iostream>
  4. int main()
  5. {
  6.     Customer c{"Tim", "Starr", 42};
  7.     auto [f, l, v] = c;
  8.     std::cout << "f/l/v:    " << f << ' ' << l << ' ' << v << '\n';
  10.     // 通过引用修改结构化绑定
  11.     auto&& [f2, l2, v2] = c;
  12.     std::string s{std::move(f2)};
  13.     f2 = "Ringo";
  14.     v2 += 10;
  15.     std::cout << "f2/l2/v2: " << f2 << ' ' << l2 << ' ' << v2 << '\n';
  16.     std::cout << "c:        " << c.firstname() << ' '
  17.         << c.lastname() << ' ' << c.value() << '\n';
  18.     std::cout << "s:        " << s << '\n';
  19. }

程序的输出如下：

  1. f/l/v:    Tim Starr 42
  2. f2/l2/v2: Ringo Starr 52
  3. c:        Ringo Starr 52
  4. s:        Tim