Structured bindings were introduced in C++17 as an alternative way of declaring variables. They allow you to decompose an object into a set of named variables, where the collection of those bindings conceptually represents the original object as a whole. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 // https://godbolt.org/z/97GaMajMP #include <cassert> #include <string> struct MyStruct { int num; std::string text; bool operator==(const MyStruct&) const noexcept = default; }; MyStruct foo() { return {42, "let's go"}; } int main() { const auto& [n, t] = foo(); MyStruct ms{n, t}; assert(ms == foo()); return 0; } Structured bindings before C++26 Up to C++23, structured bindings could appear in: simple declarations (as shown above), and range-based for loops. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 // https://godbolt.org/z/Tf8s4sdrf #include <iostream> #include <string> #include <vector> struct MyStruct { int num; std::string text; }; int main() { std::vector<MyStruct> v{ {42, "hello"}, {51, "there"} }; for(const auto&[num, text] : v) { std::cout << "num: " << num << ", text: " << text << '\n'; } return 0; } /* num: 42, text: hello num: 51, text: there */ However, you could not use structured binding declarations in conditions (for example, in if or while statements). What’s new in C++26? C++26 brings some signigicant improvements to structured bindings: Individual bindings can be annotated with attributes Structured bindings can be declared constexpr Structured bindings can introduce a parameter pack And of course, there is the topic of this article: Structured binding declarations are now allowed directly in conditions. This change comes from P0963R3 Structured bindings in conditions As of C++26, the following becomes valid: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 // https://godbolt.org/z/bP58h9153 #include <iostream> #include <optional> #include <string> struct Result { bool is_successful; std::optional<std::string> error_message; explicit operator bool() const noexcept { return is_successful; } }; Result foo(int i) { if (i % 2 == 0) { return {true}; } else { return {false, "that didn't work!"}; } } int main() { for (int n : {1, 2}) { if (const auto& [is_successful, error_message] = foo(n)) { std::cout << "no error\n"; } else { std::cout << "there was an error: " << error_message.value_or("") << '\n'; } } return 0; } /* there was an error: that didn't work! no error */ What’s going on here? The initializer (foo(n)) is evaluated first. The condition is then evaluated by invoking operator bool() on the initialized object. The structured binding is introduced, and the bindings are available in both the if and the else branches. This mirrors the existing rules for init-statements in if, but now extended to structured bindings as well. A key requirement is that the decomposed object must be contextually convertible to bool. Without an operator bool, the condition would be ill-formed. Why is this useful? This addition significantly improves expressiveness and readability. It is especially helpful when: a function returns a status together with additional data, a result may or may not be present along with diagnostic information (for example, std::expected-like types), an operation naturally produces multiple logically related values. The motivation section of the paper contains several realistic examples illustrating these use cases. Evaluation order and decomposition One subtle but important design decision concerns when decomposition happens. The chosen semantics are: 1) Initialize the object. 2) Evaluate the condition (via contextual conversion to bool). 3) Introduce and initialize the structured bindings. This sequencing ensures that condition checking is well-defined and consistent with existing language rules, while still allowing the bindings to be used in both branches. Conclusion Structured bindings in conditions may look like a small syntax sugar, but they let us write much more expressive conditional logic. By allowing decomposition and condition checking to live side by side, C++26 reduces boilerplate, improves locality, and better supports modern result types that bundle status and data together. This is a pragmatic, well-integrated evolution of a feature that has already proven its value since C++17. Connect deeper If you liked this article, please hit on the like button, subscribe to my newsletter and let’s connect on Twitter!

Sandor Dargo's blog provides practical insights into software development, Agile methodologies, and personal productivity. Readers can explore articles on topics such as Scrum, Kanban, and Agile project management, as well as techniques for improving coding skills and software design. Additionally, they can learn about tools, frameworks, and strategies for enhancing their effectiveness as software developers and team members.

Sandor Dargo

C++26 introduces the ability to use structured binding declarations directly in conditions (if, while statements), a feature previously unavailable before C++26. The initializer is evaluated first, then the condition via operator bool(), and finally the bindings are introduced and available in both if and else branches. This is especially useful when functions return a status alongside additional data, such as std::expected-like types. The post also briefly covers other C++26 structured binding improvements: attribute annotations, constexpr declarations, and parameter pack introduction.

C++26: Structured bindings in conditions