structured-bindings

C++17 standard introduces a new structured bindings feature, which was initially proposed in 2015 and whose syntactic appearance was widely discussed later. Some uses for them come to mind as soon as you look through documentation. Aggregates decomposition Let's declare a tuple: std::tuple<int, std::string> t(42, "foo"); Named elementwise copies may be easily obtained with structured bindings in one line: auto [i, s] = t; which is equivalent to: auto i = std::get<0>(t); auto s = std::get<1>(t); or int i; std::string s; std::tie(i, s) = t; References to tuple elements can also be obtained

I ran into a rather subtle bug when using std::minmax with structured bindings. It appears that passed rvalues will not always be copied as one might expect. Originally I was using a T operator[]() const on a custom container, but it seems to be the same with a literal integer. #include <algorithm> #include <cstdio> #include <tuple> int main() { auto [amin, amax] = std::minmax(3, 6); printf("%d,%d\n", amin, amax); // undefined,undefined int bmin, bmax; std::tie(bmin, bmax) = std::minmax(3, 6); printf("%d,%d\n", bmin, bmax); // 3,6 } Using GCC 8.1.1 with -O1 -Wuninitialized will result in 0,0

Is it possible to determine how many variable names should I to specify in square brackets using structured bindings syntax to match the number of data members of a plain right hand side struct ? I want to make a part of generic library, which uses structured bindings to decompose arbitrary classes into its constituents. At the moment there is no variadic version of structured bindings (and, I think, cannot be for current syntax proposed), but my first thought is to make a set of overloadings of some function decompose() , which performs decomposition of struct parameter into a set of its

I found the original proposal for *C++ structured bindings here . It proposes a way to easily bind multiple return values, i.e.: auto {a, b} = minmax(data); But now I see that everyone points to the C++17/C++1z proposal syntax of auto [a, b] = minmax(data); Now that I learned "lists are written { like, this }" there comes a new list-syntax? Why? What is the problem with curly braces here? This is still under debate. It's difficult to be certain which syntax will be least confusing given how many uses there are for [] and {} already. There's also the risk that "least confusing" and "easiest to

Functional languages with pattern matching (sometimes?) have the possibility to ignore some bound values, but with C++17 structured bindings there seem to be no way to do that ( std::ignore with structured bindings? ). The advice is to use a dummy name, but then we'll get warnings about unused variables. With the latest heads of both clang and gcc, this does the expected thing, which is nice and useful, [[maybe_unused]] auto x =4 ; // fine, no warning [[maybe_unused]] auto [a,dummyb,dummyc] = std::tuple<int,int,float>(1,1,1.0f); but I would also have hoped this would work: auto [g,[[maybe

With the following code, I get a compile error C2065 'a': undeclared identifier (using visual studio 2017): [] { auto [a, b] = [] {return std::make_tuple(1, 2); }(); auto r = [&] {return a; }(); //error C2065 }(); However, the following code compiles: [] { int a, b; std::tie(a, b) = [] {return std::make_tuple(1, 2); }(); auto r = [&] {return a; }(); }(); I thought that the two samples were equivalent. Is it a compiler bug or am I missing something ? Core issue 2313 changed the standard so that structured bindings are never names of variables, making them never capturable. P0588R1 's

Yesterday I've seen an interesting question here on SO about structured binding. We can sum up it as it follows. Consider the example code below: #include <tuple> #include <type_traits> int main() { auto tup = std::make_tuple(1, 2); auto & [ a, b ] = tup; // the following line won't compile for a isn't a reference // static_assert(std::is_reference_v<decltype(a)>); } In this case decltype(a) is int (probably) because of this bullet (working draft): if e is an unparenthesized id-expression naming a structured binding [...], decltype(e) is the referenced type as given in the specification of the