c++ - 带有引用元组的结构化绑定(bind)引用

Question

Structured binding Case2 in cppreference有点难以理解。基本上，我想澄清这些情况

int x = 1;
double y = 2.0;
auto [a, b] = std::forward_as_tuple(x, y);   //a, b are both reference, why?
auto&& [c, d] = std::forward_as_tuple(x, y); //What's the difference of this and above?
auto&& [e, f] = std::tuple{x, y};  //why are NOT e, f rvalue references? Resharper shows them as value type not reference type

如果有一些函数返回引用元组，我如何使用结构化绑定(bind)制作拷贝？

std::tuple<int&, double&> f;
auto [x, y] = f(); //But I want a copy from the reference, how?

Answer 1

std::forward_as_tuple(x, y)给你一个tuple<int&, double&> .绑定(bind)的类型是 int&和 double& (就像绑定(bind)到 tuple<int, double> 的类型是 int 和 double 一样)。基本上:

auto [a, b] = std::forward_as_tuple(x, y);
auto&& [c, d] = std::forward_as_tuple(x, y);

表现得好像:

auto __e = std::forward_as_tuple(x, y);
using __E = remove_reference_t<decltype(__e)>;
tuple_element_t<0, __E>&& a = std::get<0>(std::move(__e));
tuple_element_t<1, __E>&& b = std::get<1>(std::move(__e));

auto&& __f = std::forward_as_tuple(x, y);
using __F = remove_reference_t<decltype(__f)>;
tuple_element_t<0, F>&& c = std::get<0>(std::move(__f));
tuple_element_t<1, F>&& d = std::get<1>(std::move(__f));

所以 a是对 int& 的右值引用和 c是对 double& 的右值引用, 所以 int&和 double&分别。这个特殊的表述(我特别称它为对引用的引用，而不是只称它为 int& )是必要的，因为 decltype(name)在哪里 name是一个结构化的绑定(bind)给你引用的类型，这就是为什么 decltype(a)会给你 int& .
上面也显示了 [a, b]之间的区别。和 [c, d]案例: auto对比 auto&&声明适用于我们正在解构的未命名对象。它不会影响绑定(bind)本身†。
这个案例:

auto&& [e, f] = std::tuple{x, y};

不提供引用，因为它解压到:

auto&& __g = std::tuple{x, y};
using __G = remove_reference_t<decltype(__g)>;
tuple_element_t<0, G>&& e = std::get<0>(std::move(__g));
tuple_element_t<1, G>&& f = std::get<1>(std::move(__g));

所以 e是对 int 的右值引用, 这意味着 decltype(e)是 int ，而不是 int& .

And if there is some function return tuple of reference, how can I make a copy using structured binding?

您无法使用结构化绑定(bind)制作拷贝。结构化绑定(bind)仅仅是关于解构一个对象，它根本不是关于改变任何东西。如果要制作拷贝，则必须手动进行:

std::tuple<int&, double&> f = /* ... */;
std::tuple<int, double> actual_copy = f;
auto& [x, y] = actual_copy; 

†在上述情况下，因为被解构的底层对象是左值引用( auto& )，这在技术上使绑定(bind)本身成为左值引用而不是右值引用，尽管我不确定这是否真的是有意义的区别。