结构化绑定和转发引用混合得好吗？

Question

我知道我能做到

auto&& bla = something();

根据something 的返回值的constness，我会得到bla 的不同类型。

这是否也适用于结构化绑定情况，例如

auto&& [bla, blabla] = something();

我猜是这样（结构化绑定搭载在 auto 初始化程序上，其行为如下），但我找不到明确的肯定。

更新：初步测试似乎符合我的预期（正确推导constness）：

#include <tuple>

using thing = std::tuple<char, int*, short&, const double, const float&>;

int main()
{
    char c = 0;
    int i = 1;
    short s = 2;
    double d = 3.;
    float f = 4.f;
    
    thing t{c, &i, s, d, f};
    
    auto&& [cc, ii, ss, dd, ff] = t;
    
    c = 10;
    *ii = 11;
    ss = 12;
    dd = 13.;
    ff = 14.f;
}

Live demo，如果auto&& 正在完成它的工作，就会出现我所期望的错误：

main.cpp: In function 'int main()':
main.cpp:20:10: error: assignment of read-only reference 'dd'
     dd = 13.;
          ^~~
main.cpp:21:10: error: assignment of read-only reference 'ff'
     ff = 14.f;

我仍然想确切地知道这种行为是在哪里指定的。

注意：使用“转发引用”来表示这种行为可能会延长它，但我没有一个好名字来给auto&& 的const 扣除部分（或模板-T&&） )。

Answer 1

是的。结构化绑定和转发引用混合得很好^†。

一般来说，任何地方^‡你可以使用auto，你可以使用auto&&来获得不同的含义。特别是对于结构化绑定，这来自[dcl.struct.bind]：

否则，e 被定义为

attribute-specifier-seq_optdecl-specifier-seq ref-qualifier_{opte 初始化器 ;}

声明永远不会被解释为函数声明，并且声明中除 declarator-id 之外的部分取自相应的结构化绑定声明。

[dcl.dcl] 中对这些部分有进一步的限制：

带有标识符列表的简单声明称为结构化绑定声明（[dcl.struct.bind]）。 decl-specifier-seq 应仅包含 type-specifier auto 和 cv-限定符。 initializer 的格式为“=assignment-expression”，格式为“{assignment-expression} ”，或“(assignment-expression)”形式，其中assignment-expression是数组或非联合类类型。

把它放在一起，我们可以分解你的例子：

auto&& [bla, blabla] = something();

声明这个未命名的变量：

auto               && e = something();
~~~~               ~~     ~~~~~~~~~~~
decl-specifier-seq        initializer
                   ref-qualifier

该行为源自[dcl.spec.auto]（特别是here）。在那里，我们确实对 initializer 进行了推理：

template <typename U> void f(U&& );
f(something());

auto 被 U 替换，&& 继续存在。这是我们的转发参考。如果演绎失败（只有当 something() 是 void 时它才会失败），我们的声明是错误的。如果成功，我们就获取推导出的U 并将我们的声明视为：

U&& e = something();

根据 something() 的值类别和类型，这使得 e 成为左值或右值引用，即 const 限定为 not。

其余的结构化绑定规则遵循 [dcl.struct.bind]，基于 e 的底层类型，something() 是否为左值，以及 e 是否为左值参考。

---

^† 有一个警告。对于结构化绑定，decltype(e) 始终是referenced type，而不是您可能期望的类型。例如：

template <typename F, typename Tuple>
void apply1(F&& f, Tuple&& tuple) {
    auto&& [a] = std::forward<Tuple>(tuple);
    std::forward<F>(f)(std::forward<decltype(a)>(a));
}

void foo(int&&);

std::tuple<int> t(42);
apply1(foo, t); // this works!

我通过我的tuple 是一个左值，您希望将其底层元素作为左值引用传递，但它们实际上会被转发。这是因为decltype(a) 只是int（被引用的类型），而不是int&（a 的行为方式）。需要记住的一点。

^‡有两个地方我能想到不是这种情况。

在 trailing-return-type 声明中，您必须只使用 auto。你不能写，例如：

auto&& foo() -> decltype(...);

我能想到的唯一其他可能不是这种情况的地方是概念 TS 的一部分，您可以在更多地方使用 auto 来推断/约束类型。在那里，我认为当您推断的类型不是引用类型时使用转发引用将是不正确的：

std::vector<int> foo();
std::vector<auto> a = foo();   // ok, a is a vector<int>
std::vector<auto&&> b = foo(); // error, int doesn't match auto&&