Structured Binding

Imagine we have an object that contains a collection of other objects, such as an instance of our Vector3 struct from previous lessons:

1struct Vector3 {
2  float x;
3  float y;
4  float z;
5};
6
7int main() {
8  Vector3 SomeVector{1.0, 2.0, 3.0};
9};

Often, we'll want to extract all of its members to standalone variables for further operations:

1struct Vector3 {
2  float x;
3  float y;
4  float z;
5}
6
7int main() {
8  Vector3 SomeVector{1.0, 2.0, 3.0};
9  float a { SomeVector.x };
10  float b { SomeVector.y };
11  float c { SomeVector.z };
12};

C++ offers a convenient shortcut to this, called structured binding.

The syntax to use structured binding looks like this:

1#include <iostream>
2using namespace std;
3
4struct Vector3 {
5  float x;
6  float y;
7  float z;
8};
9
10int main(){
11  Vector3 SomeVector{1.0, 2.0, 3.0};
12  auto [a, b, c]{SomeVector}; 
13
14  cout << "a = " << a
15    << ", b = " << b
16    << ", c = " << c;
17}

1a = 1, b = 2, c = 3

To break this down, first, we use the auto keyword, which asks the compiler to automatically determine what type each of our new variables will have.

Note we must use auto here, even if all our variables will have the same type.

After auto, we open up a set of square brackets - [ and ]. Within these brackets, we specify the name we want to use for each variable we create.

Finally, we provide the object we want to use to initialize these variables. We can use any initialization syntax here - the following are all options:

1auto [a, b, c]{SomeVector};
2auto [d, e, f](SomeVector);
3auto [g, h, i] = SomeVector;

1#include <iostream>
2using namespace std;
3
4class Character {
5public:
6  string Name{"Goblin Warrior"};
7  int Level{5};
8  int Health{100};
9};
10
11int main(){
12  Character MyCharacter;
13  // Access MyCharacter variables
14}

Much like aggregate initialization, structured binding is mostly useful for simple data types, such as our Vector3 struct.

Once our type gets more complicated, structured binding has some limitations. Firstly, we need to unpack every variable from our object, even if we only need some of them.

An additional effect of this limitation is that, if our type has private data members, we can't access all of them, so we can't use structured binding at all.

In those cases, we need to fall back to traditional approaches, such as accessing variables one-by-one, or providing a member function to support the desired access pattern.

In this lesson, we explored the concept of structured binding in C++. Here are the key takeaways:

• Structured binding provides a concise and readable way to unpack members from simple types.
• The auto keyword is essential in structured binding, allowing the compiler to infer the types of the unpacked variables.
• With structured binding, we must unpack every public member.
• If the type has any private members, we can't use structured binding.
• With more advanced knowledge, we'll be able to overload structured binding for our custom types, giving us more flexibility