Structured bindings in C++17, 5 years later


Structured bindings are a C++17 characteristic that permits you to bind a number of variables to the weather of a structured object, comparable to a tuple or struct, in a single declaration. This will make your code extra concise and simpler to learn, particularly when working with advanced knowledge constructions. On this weblog submit, we are going to have a look at the essential syntax of this cool characteristic, its use circumstances, and even some real-life code examples.

The fundamentals of structured binding


Ranging from C++17, you’ll be able to write:

std::set<int> mySet;
auto [iter, inserted] = mySet.insert(10);

insert() returns std::pair indicating if the factor was inserted or not, and the iterator to this factor. As an alternative of pair.first and pair.second, you should use variables with concrete names.

(You may as well assign the outcome to your variables through the use of std::tie(); nonetheless, this method just isn’t as handy as structured bindings in C++17)

Such syntax known as a structured binding expression.

The Syntax


The essential syntax for structured bindings is as follows:

auto [a, b, c, ...] = expression;
auto [a, b, c, ...] { expression };
auto [a, b, c, ...] ( expression );

The compiler introduces all identifiers from the a, b, c, ... checklist as names within the surrounding scope and binds them to sub-objects or parts of the thing denoted by expression.

Behind the scenes, the compiler would possibly generate the next pseudo code:

auto tempTuple = expression;
utilizing a = tempTuple.first;
utilizing b = tempTuple.second;
utilizing c = tempTuple.third;

Conceptually, the expression is copied right into a tuple-like object (tempTuple) with member variables which are uncovered by a, b and c. Nonetheless, the variables a, b, and c usually are not references; they’re aliases (or bindings) to the generated object member variables. The non permanent object has a novel identify assigned by the compiler.

For instance:

std::pair a(0, 1.0f);
auto [x, y] = a;

x binds to int saved within the generated object that may be a copy of a. And equally, y binds to float.



A number of modifiers can be utilized with structured bindings (equally like on auto):

const modifiers:

const auto [a, b, c, ...] = expression;


auto& [a, b, c, ...] = expression;
auto&& [a, b, c, ...] = expression;

For instance:

std::pair a(0, 1.0f);
auto& [x, y] = a;
x = 10;  // write entry
// a.first is now 10

Within the instance, x binds to the factor within the generated object, which is a reference to a.

Now it’s additionally comparatively straightforward to get a reference to a tuple member:

auto& [ refA, refB, refC, refD ] = myTuple;

Or higher by way of a const reference:

const auto& [ refA, refB, refC, refD ] = myTuple;

You may as well add [[attribute]] to structured bindings:

[[maybe_unused]] auto& [a, b, c, ...] = expression;



Structured Binding just isn’t solely restricted to tuples; now we have three circumstances from which we will bind from:

1. If the initializer is an array:

// works with arrays:
double myArray[3] = { 1.0, 2.0, 3.0 };  
auto [a, b, c] = myArray;

On this case, an array is copied into a short lived object, and a, b, and c refers to copied parts from the array.

The variety of identifiers should match the variety of parts within the array.

2. If the initializer helps std::tuple_size<>, gives get<N>() and likewise exposes std::tuple_element capabilities:

std::pair myPair(0, 1.0f);
auto [a, b] = myPair; // binds myPair.first/second

Within the above snippet, we bind to myPair. However this additionally means you’ll be able to present assist to your lessons, assuming you add the get<N> interface implementation. See an instance within the later part.

3. If the initializer’s sort incorporates solely non-static knowledge members:

struct Level  { 
    double x; 
    double y; 

Level GetStartPoint() {
    return { 0.0, 0.0 };
const auto [x, y] = GetStartPoint();

x and y seek advice from Level::x and Level::y from the Level construction.

The category doesn’t need to be POD, however the variety of identifiers should equal to the variety of non-static knowledge members. The members should even be accessible from the given context.

C++17/C++20 modifications


In the course of the work on C++20, there have been a number of proposals that improved the preliminary assist for structured bindings:

  • P0961 – Stress-free the structured bindings customization level discovering guidelines
  • P0969 – Permit structured bindings to accessible members
  • P1091 – Extending structured bindings to be extra like variable declarations
  • P1381 – Reference seize of structured bindings

It seems like GCC carried out these options working even for the C++17 mode.

For instance, you’ll be able to even seize them in lambda:

std::pair xy { 42.3, 100.1 };
auto [x, y] = xy;
auto foo = [&x, &y]() {
    std::cout << std::format("{}, {}", x, y);

See at Compiler Explorer

Iterating by maps


When you’ve got a std::map of parts, you would possibly know that internally, they’re saved as pairs of <const Key, ValueType>.

Now, while you iterate by parts of that map:

for (const auto& elem : myMap) { ... }

You must write elem.first and elem.second to seek advice from the important thing and worth. One of many coolest use circumstances of structured binding is that we will use it inside a spread primarily based for loop:

std::map<KeyType, ValueType> myMap;    
// C++14:
for (const auto& elem : myMap) {  
    // elem.first - is velu key
    // elem.second - is the worth
// C++17:
for (const auto& [key,val] : myMap) {  
    // use key/worth instantly

Within the above instance, we bind to a pair of [key, val] so we will use these names within the loop. Earlier than C++17, you needed to function on an iterator from the map – which returns a pair <first, second>. Utilizing the actual names key/worth is extra expressive.

The above approach can be utilized within the following instance:

#embody <map>
#embody <iostream>

int primary() {
    const std::map<std::string, int> mapCityPopulation {
        { "Beijing", 21'707'000 },
        { "London", 8'787'892 },
        { "New York", 8'622'698 }
    for (const auto&[city, population] : mapCityPopulation)
        std::cout << metropolis << ": " << inhabitants << 'n';

Run @Compiler Explorer

Within the loop physique, you’ll be able to safely use the metropolis and inhabitants variables.

Working with constructions and arrays


Right here’s one other instance the place structured binding could be useful:

#embody <iostream>
#embody <format>
#embody <array>

struct Colour {
    // inner illustration...
    int knowledge { 0 };
    int mannequin { 0 };

    std::array<unsigned char, 3> getRGB() const {
        // do some conversion from the interior mannequin...
        return {255, 128, 255 };
    std::array<double, 3> getHSV() const {
        // do some conversion from the interior mannequin...
        return {0.5, 0.1, 1. };

int primary() {
    Colour col{};
    auto [r, g, b] = col.getRGB();
    std::cout << std::format("{}, {}, {}n", r, g, b);
    auto [h, s, v] = col.getHSV();
    std::cout << std::format("{}, {}, {}n", h, s, v);

Run @Compiler Explorer

As you’ll be able to see, the code has a Colour construction which may include some inner illustration, and you utilize getters to get RGB or HSV fashions. Due to the structured binding, it’s straightforward to call these sub-objects, somewhat than depend on arrays.

Actual code


Let’s take a look at some code within the wild. I discovered the next use circumstances:

In Tensorflow:

auto [_, was_inserted] =
      done_events_.insert({device_ordinal, std::transfer(done_event)});

Powertoys Microsoft: updating.cpp

auto [installer_download_url, installer_filename] = extract_installer_asset_download_info(release_object);
co_return new_version_download_info{ extract_release_page_url(release_object),
                                                 std::transfer(installer_filename) };

Microsoft Terminal: state.cpp

const auto [colorForeground, colorBackground] = renderSettings.GetAttributeColors(textAttributes);

std::from_chars() and bitcoin: bitcoin

const auto [first_nonmatching, error_condition] 
    = std::from_chars(val.knowledge(), val.knowledge() + val.dimension(), outcome);

Again to you

  • Do you utilize structured bindings?
  • In what use case you will have tried them?

Share your suggestions within the feedback under.


Leave a Reply

Your email address will not be published. Required fields are marked *