复制省略是否适用于结构化绑定

Question

强制复制省略是否适用于通过结构化绑定进行的分解？这适用于以下哪种情况？

// one
auto [one, two] = std::array<SomeClass>{SomeClass{1}, SomeClass{2}};

// two
auto [one, two] = std::make_tuple(SomeClass{1}, SomeClass{2});

// three
struct Something { SomeClass one, two; };
auto [one, two] = Something{};

我怀疑只有第三种情况允许复制省略，因为前两种情况将是 "decomposed" via std::get<> and std::tuple_size<> and std::get<> returns当参数是右值时的 xvalues

引用标准也很好！

Answer 1

Does mandatory copy elision apply to decomposition via structured bindings? Which of the following cases does that apply to?

是的，全部。结构化绑定的要点是为您提供对您要绑定到的类型的解构元素的命名引用。这个：

auto [one, two] = expr;

只是语法糖：

auto __tmp = expr;
some_type<0,E>& a = some_getter<0>(__tmp);
some_type<1,E>& b = some_getter<1>(__tmp);

其中 some_type 和 some_getter 取决于我们正在解构的类型（数组、类元组或具有所有 public 非静态数据成员的类型）。

auto __tmp = expr行强制复制省略，其他行none涉及复制。

评论中的示例有些混乱，所以让我详细说明一下：

auto [one, two] = std::make_tuple(Something{}, Something{});

那个expands into:

auto __tmp = std::make_tuple(Something{}, Something{}); // note that it is from
// std::make_tuple() itself that we get the two default constructor calls as well
// as the two copies.
using __E = std::remove_reference_t<decltype(__tmp)>; // std::tuple<Something, Something>

那么，由于 __E 是 not an array type but is tuple-like, we introduce variables via an unqualified call to get looked up in the associated namespace of __E. The initializer will be an xvalue and the types will be rvalue references:

std::tuple_element_t<0, __E>&& one = get<0>(std::move(__tmp));
std::tuple_element_t<1, __E>&& two = get<1>(std::move(__tmp));

请注意，虽然 one 和 two 都是 __tmp 的右值引用，但 decltype(one) 和 decltype(two) 将 both yield Something 而不是 Something&&.

Answer 2

有趣的问题：

#include <iostream>
#include <array>
#include <tuple>
#include <typeinfo>
using std::cout;
using std::endl;

struct SomeClass
{
    int baz;

    SomeClass(int _b): baz(_b) {
        cout << __PRETTY_FUNCTION__ << " = " << baz << endl;
    }
    SomeClass(SomeClass&&) {
        cout << __PRETTY_FUNCTION__ << endl;
    }
    SomeClass(const SomeClass&) {
        cout << __PRETTY_FUNCTION__ << endl;
    }
};

template<typename T> void tell(T&& a)
{
    cout << "Tell: " << __PRETTY_FUNCTION__ << " = " << a.baz << endl;
}

int main()
{
     // one
     cout << "= 1 =" << endl;
     auto [one, two] = std::array<SomeClass,2>{SomeClass{1}, SomeClass{2}};
     cout << "===" << endl;
     tell(one); tell(two);
     // two
     cout << endl << "= 2 =" << endl;
     auto [one2, two2] = std::make_tuple(SomeClass{1}, SomeClass{2});
     cout << "===" << endl;
     tell(one2); tell(two2);
     // three
     cout << endl << "= 3 =" << endl;
     struct Something { SomeClass one{1}, two{2}; };     
     auto [one3, two3] = Something{}; 
     cout << "===" << endl;
     tell(one3); tell(two3);

    return 0;
}

产生输出：

= 1 =
SomeClass::SomeClass(int) = 1
SomeClass::SomeClass(int) = 2
===
Tell: void tell(T&&) [with T = SomeClass&] = 1
Tell: void tell(T&&) [with T = SomeClass&] = 2

= 2 =
SomeClass::SomeClass(int) = 2
SomeClass::SomeClass(int) = 1
SomeClass::SomeClass(SomeClass&&)
SomeClass::SomeClass(SomeClass&&)
===
Tell: void tell(T&&) [with T = SomeClass&] = 0
Tell: void tell(T&&) [with T = SomeClass&] = 4199261

= 3 =
SomeClass::SomeClass(int) = 1
SomeClass::SomeClass(int) = 2
===
Tell: void tell(T&&) [with T = SomeClass&] = 1
Tell: void tell(T&&) [with T = SomeClass&] = 2

第二种情况使用复制或移动（如果可用）构造函数。值没有被初始化，因为我故意没有在构造函数中这样做。

绑定的协议有3种

绑定到数组
绑定到类似元组的类型
绑定到 public 数据成员

第二种情况（抱歉，我无法访问 C++17 pdf，所以 cppreference）：

Each identifier becomes a variable whose type is "reference to std::tuple_element<i, E>::type": lvalue reference if its corresponding initializer is an lvalue, rvalue reference otherwise. The initializer for the i-th identifier is

e.get<i>(), if lookup for the identifier get in the scope of E by class member access lookup finds at least one declaration (of whatever kind)

Otherwise, get<i>(e), where get is looked up by argument-dependent lookup only, ignoring non-ADL lookup

示例的第一阶段和第二阶段实际上是绑定到类似元组的类型。但是......在第二阶段我们用什么来初始化？构造元组的模板函数：

 std::make_tuple(SomeClass{1}, SomeClass{2});

这实际上会复制或移动值。可能会发生进一步的复制省略，但

 auto t = std::make_tuple(SomeClass{1}, SomeClass{2});
 auto [one2, two2] = t;

会产生这个输出：

SomeClass::SomeClass(int) = 2
SomeClass::SomeClass(int) = 1
SomeClass::SomeClass(SomeClass&&)      //make_tuple
SomeClass::SomeClass(SomeClass&&)
SomeClass::SomeClass(const SomeClass&) //assignment 
SomeClass::SomeClass(const SomeClass&)

虽然正确地去糖化结构化绑定看起来像：

 auto t = std::make_tuple(SomeClass{1}, SomeClass{2});
 auto& one2 = std::get<0>(t);
 auto& two2 = std::get<1>(t);

并且输出与原始匹配：

SomeClass::SomeClass(int) = 2
SomeClass::SomeClass(int) = 1
SomeClass::SomeClass(SomeClass&&)
SomeClass::SomeClass(SomeClass&&)
===

因此，发生的复制或移动操作来自构建我们的 tuple。我们会避免这种情况，如果我们使用通用引用构造元组，那么两者都会脱糖

 auto t = std::tuple<SomeClass&&, SomeClass&&>(SomeClass{1}, SomeClass{2});
 auto& one2 = std::get<0>(t);
 auto& two2 = std::get<1>(t);

和结构化绑定

 auto [one2, two2] = std::tuple<SomeClass&&, SomeClass&&>(SomeClass{1}, SomeClass{2});

会导致复制省略。

复制省略是否适用于结构化绑定

Does copy elision work with structured bindings

c++

rvalue

copy-elision

c++17

structured-bindings