c++17之结构化绑定

结构化绑定允许通过对象的元素或成员初始化多个实体。

例如，假设你定义了一个结构体包含两个成员：

struct MyStruct

{

    int i = 0;

    std::string s;

};

MyStruct ms;

可以使用以下声明将该结构的成员直接绑定到新名称:

auto [u,v] = ms;

这里，u和v的名称就是所谓的结构化绑定。

结构化绑定对于返回结构或数组的函数尤其有用。

例如，假设您有一个返回结构的函数:

MyStruct getStruct()

{
    return MyStruct{42, "hello"};
}

在这里可以直接将结果分配给两个实体，并为返回的数据成员提供本地名称:

auto[id,val] = getStruct();

这里，id和val是返回结构的成员i和s的名称。它们有相应的类型int和std::string，可以作为两个不同的对象使用:

if (id > 30)

{
    std::cout << val;
}

这样做的好处是直接访问和将值直接绑定到表示其目的语义的名称，从而使代码更具可读性
要在没有结构化绑定的情况下迭代std::map<>的元素，编写程序:

for (const auto& elem : mymap)

{
    std::cout << elem.first << ": " << elem.second << '\n';
}

通过使用结构化绑定，代码变得可读性更强:

for (const auto& [key,val] : mymap)

{
    std::cout << key << ": " << val << '\n';
}

我们可以直接使用每个元素的键和值成员，使用名称清楚地显示它们具体的含义。

注意对于结构体，结构化绑定不能绑定static成员：

struct MyStruct
{
    int i = 0;
    const static int a;
    std::string s;

};

const int MyStruct::a = 19;

MyStruct ms{100, "hhhh"};

int main()
{
     auto [id, name] = ms;//OK
	//auto [id, ss, name] = ms;//error: 3 names provided for structured binding, while ‘MyStruct’ decomposes into 2 elements
	std::cout << id << ", " << name << std::endl;
}

1. 接下来详细介绍下structured bindings

为了理解结构化绑定，必须注意其中涉及一个新的匿名变量。作为结构绑定引入的新名称引用这个匿名变量的成员/元素。

auto [u, v] = ms;

其行为就像我们用ms初始化一个新的实体e，让结构化绑定u和v成为这个新对象成员的别名，类似于定义:

auto e = ms;
auto& u = e.i;
auto& v = e.s;

唯一的区别是我们没有e的名称，所以我们不能直接通过名称访问初始化的实体。

std::cout << u << ' ' << v << '\n';   //e.i和e.s的值，是从ms.i和ms.s拷贝过来的。

只要到它的结构化绑定存在，匿名的这个e就存在。因此，当结构化绑定超出范围时，它将被销毁。
因此，除非使用引用，否则修改用于初始化的值不会影响结构化绑定初始化的名称(反之亦然):

MyStruct ms{42,"hello"};
auto [u,v] = ms;
ms.i = 77;
std::cout << u; // prints 42
u = 99;
std::cout << ms.i; // prints 77

u和ms.i有不同的地址。

当为返回值使用结构化绑定时，应用相同的原则。初始化，如

auto [u,v] = getStruct();

行为就像我们用getStruct()的返回值初始化一个新的实体e，以便结构化绑定u和v成为e的两个成员/元素的别名，类似于定义:

auto e = getStruct();
auto& u = e.i;
auto& v = e.s;

也就是说，结构化绑定绑定到从返回值初始化的新实体，而不是直接绑定到返回值。
对匿名变量e的地址和字节对齐也得到了保证，以便结构化绑定与它们绑定到的相应成员对齐。

例1:

#include <iostream>
#include <string>
#include <assert.h>

struct MyStruct
{
    int i = 0;
    std::string s;
};

MyStruct ms{42, "hello"};

int main()
{
    auto [u,v] = ms;
    assert(&((MyStruct*)&u)->s == &v); // 

    return 0;
}

这里，((MyStruct*)&u)生成一个指向匿名实体的指针。u和v的地址和字节对齐和结构体里面变量一样的规则。

具体可以看下调试结果：

我们可以使用限定符，如const和reference。同样，这些限定符也适用于整个匿名实体e。通常，效果类似于直接将限定符应用于结构化绑定，但是要注意，情况并非总是如此(请看下面的内容)。
例如，我们可以声明到const引用的结构化绑定:

const auto& [u,v] = ms; // a reference, so that u/v refer to ms.i/ms.s

这里，匿名实体被声明为一个const引用，这意味着u和v是初始化的对ms的const引用的成员i和s的名称，因此，对ms成员的任何更改都会影响u和/或v的值。

ms.i = 77; // affects the value of u
std::cout << u; // prints 77

声明为非const引用，您甚至可以修改用于初始化的对象/值的成员:

MyStruct ms{42,"hello"};
auto& [u,v] = ms; // the initialized entity is a reference to ms
ms.i = 77; // affects the value of u
std::cout << u; // prints 77
u = 99; // modifies ms.i
std::cout << ms.i; // prints 99

如果用于初始化结构化绑定引用的值是一个临时对象，则通常将临时对象的生存期扩展到结构化绑定的生存期:

MyStruct getStruct();
...
const auto& [a,b] = getStruct();  //在这里const auto&既可以用到左值也可以用到右值上。
std::cout << "a: " << a << '\n'; // OK

2.限定符不一定适用于结构化绑定：

如前所述，限定符适用于新的匿名实体，而不一定适用于作为结构化绑定引入的新名称。这一点的区别可以通过指定对齐方式来说明:

alignas(16) auto [u,v] = ms; // align the object, not v /* 理解不是很好，gdb没有调试出什么结果*/

在这里，我们对齐初始化的匿名实体，而不是结构化绑定u和v。
出于同样的原因，虽然使用了auto，但结构化绑定不会衰变。如果我们有一个原始数组结构:

例2：

#include <iostream>

struct S
{
    const char x[6];
    const char y[3];
};

int main()
{
    S s1{};

    auto [a, b] = s1; // a and b get the exact member types

    return 0;
}

结果如下：

a的类型仍然是const char[6]。同样，自动应用于匿名实体，它作为一个整体不会衰减。这不同于初始化一个新的对象与自动，其中类型衰减:

例3：

#include <iostream>

struct S
{
    const char x[6];
    const char y[3];
};

int main()
{
    S s1{};

    auto [a, b] = s1;

    auto a2 = a;  // a2 gets decayed type of a

    return 0;
}

结果如下：

3.移动语义

移动语义的规则如下:

MyStruct ms = { 42, "Jim" };
auto&& [v,n] = std::move(ms); // 这里新的匿名实体e相当于是对ms的右值引用，并没有真正移动ms，[知识点1]

结构化绑定v和n表示一个匿名实体e作为ms的右值引用，ms仍然保持其值:

std::cout << "ms.s: " << ms.s << '\n'; // prints "Jim" ，这里可以打印ms.s

但是你可以移动赋值n，也就是ms.s:

std::string s = std::move(n); // moves ms.s to s
std::cout << "ms.s: " << ms.s << '\n'; // prints unspecified value
std::cout << "n: " << n << '\n'; // prints unspecified value
std::cout << "s: " << s << '\n'; // prints "Jim"

与移动规则一样，从对象中移出的对象处于有效状态，值未指定。因此，可以打印值，但不要对打印的内容做任何假设
这与用ms的移动值初始化新实体[知识点1]略有不同:

MyStruct ms = { 42, "Jim" };
auto [v,n] = std::move(ms); // 这里新的匿名实体e从ms移动了值

这里，初始化的匿名实体是一个新对象，初始化时使用的是值是从ms移动来的。因此, ms已经丢失了它的值:

std::cout << "ms.s: " << ms.s << '\n'; // prints unspecified value
std::cout << "n: " << n << '\n'; // prints "Jim"

仍然可以移动赋值n或在那里赋值，但这不影响ms.s

std::string s = std::move(n); // moves n to s
n = "Lara";
std::cout << "ms.s: " << ms.s << '\n'; // prints unspecified value
std::cout << "n: " << n << '\n'; // prints "Lara"
std::cout << "s: " << s << '\n'; // prints "Jim"

4.哪些地方可以使用结构化绑定使用

原则上，结构化绑定可用于具有public数据成员、原始C语言风格的数组和像tuple元组对象的结构:

a. 如果在结构体和类中所有非静态数据成员都是公共的，则可以将每个非静态数据成员绑定到一个名称。

b. 对于原始数组，可以将名称绑定到每个元素.

c. 对于任何类型，都可以使用像tuple元组API将名称绑定到API定义为“元素”的任何内容。[后续介绍如何提供tuple一样的API接口]
    该API大致由以下元素组成的类型:
    - std::tuple_size<type>::value必须返回元素的数量。
    - std::tuple_element<idx,type>::type必须返回idxth元素的类型。
    -全局或成员get<idx>()必须生成idx元素的值。

描述的可能不太清楚，后面看例子就会明白了。

标准库类型std::pair<>， std::tuple<>， std::array<>已经提供了这个API。
如果结构或类提供了像tuple元组API，则使用该API。
在所有情况下，元素或数据成员的数量都必须符合结构化绑定声明中的名称数量。你不能跳过名字，也不能重复使用名字。但是，您可以使用一个非常短的名称，比如“_”，但是在相同的范围内只能使用一次:

auto [_,val1] = getStruct(); // OK
auto [_,val2] = getStruct(); // ERROR: name _ already used

接下来将详细介绍以上的所有情况。

4.1 struct 和 class

上面的示例演示了一些用于结构和类的结构化绑定的简单案例。
注意，只有有限的继承用法是可能的。所有非静态数据成员必须是相同类定义的成员(因此，它们必须是类型的直接成员或相同的明确的公共基类的直接成员):

例4：

#include <iostream>

struct B {
    int a = 1;
    int b = 2;
};
struct D1 : B {
};

struct D2 : B {
    int c = 3;
};

int main()
{
    auto [x, y] = D1{}; // OK


    //auto [i, j, k] = D2{}; // Compile-Time ERROR


    std::cout << "x=" << x << ", y=" << y << std::endl;


    return 0;
}

结果：

4.2 原始数组

下面的代码通过原始c风格数组的两个元素初始化x和y:

例5：

#include <iostream>

int main()
{
	int arr[] = { 47, 11 };
	auto [x, y] = arr;

	//auto [z] = arr; // ERROR: number of elements doesn’t fit

	std::cout << "x=" << x << ", y=" << y << std::endl;
	return 0;
}

结果：

当然，这只有在数组仍然具有已知大小的情况下才有可能。对于作为参数传递的数组，这是不可能的，因为它衰减为对应的指针类型。
注意c++允许我们通过引用返回大小数组，所以这个特性也适用于返回数组的函数，前提是数组的大小是返回类型的一部分:

例6：

#include <iostream>

int arr[2] = {24, 42};

auto getArrayRef() -> int(&)[2]
{
	return arr;
}

decltype(arr)& getArrayRef2()
{
	return arr;
}

int main()
{
	auto& r1 = getArrayRef();
	auto r2 = getArrayRef();
	auto& r3 = getArrayRef2();
	auto r4 = getArrayRef2();

	auto [x, y] = getArrayRef2();


	return 0;
}

结果：

4.3 结构化绑定std::pair, std::tuple, and std::array

结构化绑定机制是可扩展的，因此可以向任何类型添加对结构化绑定的支持。标准库里面有std::pair<>, std::tuple<>, and std::array<>等。

4.3.1 std::array

在这里，i,j,k,l结构化绑定到了getArray的返回值std::array的元素上，而且也支持写访问，如变量w，只要绑定的对象不是一个临时的右值。

例7:

#include <iostream>
#include <array>

constexpr int size = 4;

std::array<int, size> getArray()
{
	return std::array<int, size>{11,22,33,44};
}

int main(void)
{
	std::array<int, size> stdarr{ 1,2,3,4 };

	auto [i, j, k, l] = getArray(); //i, j, k, l name the 4 elements of the copied return value
	auto& [w, x, y, z] = stdarr;
	w += 10; //支持写访问

	std::cout << stdarr[0] << std::endl;

	return 0;
}

结果如下：

4.3.2 tuple

如下代码通过getTuple返回std::tuple<>的三个元素初始化了变量a,b,c。也就是说,a得到了类型char,b得到了类型float,c得到了std::string。

#include <iostream>
#include <tuple>
#include <string>

std::tuple<char, float, std::string> getTuple()
{
	return std::make_tuple('x', 3.14, "PI");
}

int main()
{
	auto [a, b, c] = getTuple();

	return 0;
}

结果如下：

4.3.3 std::pair

作为另一个示例中,代码来处理调用的返回值插入()在一个关联/无序容器可以直接通过绑定的值,使更可读名称传达语义的目的,而不是依靠通用名称的frist和second从std::pair<>对象:

#include <iostream>
#include <map>
#include <string>

int main(void)
{
	std::map<std::string, int> coll{ {"new", 42} };

	auto [iter, result] = coll.emplace("new", 42);
	if (not result)
	{
		//if emplace failed.
		std::cout << "emplace(\"new\", 42) failed" << std::endl;
	}
	else
	{
		std::cout << "emplace(\"new\", 42) successful" << std::endl;
	}

	return 0;
}

结果如下：

在c++17之前我们需要如下书写方式：

auto ret = coll.insert({"new",42});
if (!ret.second){
// if insert failed, handle error using iterator ret.first
...
}

注意，在这个特殊的例子中，c++ 17提供了一种方法，可以使用if和初始化声明进一步改进这一点。