Structured Bindings auto without ref

[tvaneerd]

Structured Bindings auto without ref

[tvaneerd]

No, they actually are references. Or actually less than references, they are "special" references. or "synonyms":

#include <string>
#include <iostream>

struct Foo
{
   int i = 0;
   std::string s = "world";
   ~Foo() { std::cout << s; }
};

int main()
{
   auto [ i, s ] = Foo();
   std::cout << "hello ";
   s = "structured bindings";
}

program output:
hello structured bindings

I guess I should add that example.

[kioba]

i can see now, but first let me explain myself based on the example you have used in the post:

pair<int, string> stuff(); // <-- stuff() function header
auto [ i, s ] = stuff(); // <-- stuff() function call
use(s, ++i);

even my idea about reference is bad, because:

pair<int, string> stuff(); // <-- stuff() function header
auto& [a, b] = stuff(); // stuff() returns rvalue, which can not be referenced

maybe it could be simplified like the following:

std::tuple<int, std::string> stuff = std::make_tuple(1, "hello");
auto [i, s] = stuff;
use(s, ++i);

[kioba]

on the other hand if we check cppreference:Structured_binding_declaration
the example states the following:

int a[2] = {1,2};
auto f() -> int(&)[2] { return a; }
 
auto [x,y] = f(); // creates e[2], copies a into e, then x refers to e[0], y refers to e[1]
auto& [xr, yr] = f(); // xr refers to a[0], yr refers to a[1]

which means if we use auto, we get a copy of the a[2] array.

Other example like the open-std:structured bindings, which is used for the clang compiler, states the following in their example:

If E is an array type with element type T, the number of elements in the identifier-list shall be equal to the number of elements of E. Each vi is the name of an lvalue that refers to the element i-1 of the array and whose type is T; the referenced type is T. [ Note: The top-level cv-qualifiers of T are cv. -- end note ] [ Example:

      auto f() -> int(&)[2];
      auto [ x, y ] = f();   // x and y refer to elements in a copy of the array return value
      auto& [ xr, yr ] = f();  // xr and yr refer to elements in the array referred to by f's return value
    
-- end example ]

based on this you Foo example:

...
auto [ i, s ]  = { expression }; // where {expresion} is Foo()
...

each element (i and s) is direct initialized from the corresponding element of expression.

[kioba]

closed on structured binding update