July 2022 ISO C++ committee virtual meeting report

Timur Doumler

On July 25, 2022, the ISO C++ committee (also known as WG21) met via Zoom for a virtual plenary session. This plenary session was remarkable for two reasons. First, this was our last virtual meeting before we finally return to meeting in-person – the next meeting is scheduled for November 2022 in Kona, Hawaii. Second, it was the last meeting for approving new features for the upcoming C++23 standard. This means that as of now, C++23 is in feature freeze.

The exciting news is that a lot of great features have made the cut! Thanks to the tireless work of the paper authors and committee subgroups, and in particular the heroic efforts of LWG (the group responsible for standard library wording review), C++23 is looking great. Here are some of the most exciting new features that have been approved in this meeting:

• std::generator (P2502R2), a synchronous coroutine generator that makes working with C++20 coroutines a lot easier. Finally, we have some standard library support for this important coroutines use case, and don’t have to write generators by hand anymore (which is a lot of work, even for the simplest use case)!
• std::flat_map and std::flat_multimap (P0429R9), new associative container adaptors with an interface like that of std::map and std::multimap, but a lot more cache-friendly, which is great for low-latency applications. The idea is similar to boost::containers::flat_map, but the design evolved quite significantly. It is now a container adapter rather than a standalone container, and the keys and values are stored in separate containers as this was found to be more performant in certain cases.
• std::flat_set and std::flat_multiset (P1222R4), analogous to the above but for elements where the key is also the value.
• std::mdspan (P0009R18), a powerful and flexible multidimensional span which will be tremendously useful for scientific computing (those who’ve ever had to write their own multidimensional dynamic array class template know what I mean). This one took a while to standardize – the first revision of this paper was published in 2015!
• std::print (P2093R14) – the new output facility that integrates with C++20 std::format and renders std::cout obsolete. We now have a new and better way to write “Hello, World” in C++!
• std::find_last (P1223R5), a new standard algorithm that does what it says on the tin.
• import std (P2465R3). The standard library itself can now finally be imported as a C++20 module.
• Lots of additions to ranges, such as std::ranges::contains (P2302R4), std::ranges::fold (P2322R6), and std::views::cartesian_product (P2374R4).
• std::float16_t, std::float32_t, std::float64_t, std::float128_t, and std::bfloat16_t (P1467R9). Optional extended floating-point types with a defined storage width and properties defined according to ISO/IEC/IEEE 60559. They are not completely analogous to the fixed-width integer types std::int8_t, std::int16_t, etc. The new extended floating-point types are not allowed to be type aliases for the built-in types float, double, and long double, but are required to be independent types.

• #warning (P2437R1), a preprocessor directive to issue a warning. Like #error, except it’s a warning, not an error! It’s already been approved for the C language as well, and almost all major C++ compilers already support it.

I am also very happy that all three of my own proposals that were up for vote this time around have been approved as well:

• [[assume(x)]] (P1774R8). Allows the compiler to assume that the expression x is true, without evaluating it, and optimize the code based on that assumption. It’s a portable replacement for clang’s __builtin_assume, and a sharp knife for those who need to shave off the last nanoseconds of performance from their code. This is one of those proposals where getting the specification right turned out to be surprisingly hard. After over three years of work on this, I’m very happy it is finally done!
• std::start_lifetime_as<T> (P2590R2). For certain types, this allows the user to turn a sequence of bytes into a live C++ object without calling a constructor. Previously, people did this with reinterpret_cast, often unaware that this is undefined behavior (I gave a talk on this a few years ago). std::start_lifetime_as gives us a way to avoid some of these situations.
• Class template argument deduction (CTAD) from inherited constructors (P2582R1). This concludes another piece of work that started over three years ago: extending CTAD. In C++20, we already added CTAD for aggregates (P1816R0, P2082R1) and CTAD for alias templates (P1814R0), and both proved very useful. But CTAD from inherited constructors didn’t make the cut back then because I did not get the wording done in time. Three years later, it’s finally here!

The feature freeze doesn’t mean that committee work on C++23 is now finished. We now have what’s called a “committee draft” (CD), but there is more work to do. The next two committee meetings will be focused on bug fixing (“ballot resolution” in ISO language). Hopefully, nothing shocking will happen during this phase. Once that’s done, there will be just a few more bureaucratic ISO hoops to jump through, and then the new C++23 standard will ship!

Subscribe to CLion Blog updates

Subscribe form

By submitting this form, I agree to the JetBrains Privacy Policy Notification icon

By submitting this form, I agree that JetBrains s.r.o. ("JetBrains") may use my name, email address, and location data to send me newsletters, including commercial communications, and to process my personal data for this purpose. I agree that JetBrains may process said data using third-party services for this purpose in accordance with the JetBrains Privacy Policy. I understand that I can revoke this consent at any time in my profile. In addition, an unsubscribe link is included in each email.

Submit

Thanks, we've got you!