Source: Zhihu, Author: Nanshan Yanyu Zhujiang TideLink: https://zhuanlan.zhihu.com/p/107360459
C++20 is the largest version ever, akin to constructing a beautiful skyscraper, but due to time constraints, the interior decoration is still incomplete, which feels like this:
The primary task of C++23 is, of course, to continue the interior decoration of the building, so C++23 should look like this:
C++23 has four top-priority features, all of which are supplements to the standard library rather than language-level features, namely: libraries related to coroutines, a modular standard library, executors, and networking.
Library Support for Coroutines
C++20 introduced the feature of stackless coroutines, preparing for better asynchronous programming. However, due to significant controversy over the implementation of coroutines in this version, the support libraries for coroutines, such as std::generator and std::task, could not be provided in C++20 and will only be available in C++23. With the support of these libraries, everyone will be able to write coroutines.
A Modular Standard Library
C++20 introduced the modules feature, which theoretically greatly improves compilation speed. Developers can now organize their projects using modules, but the standard library itself is not modularized yet, and it is not possible to import anything from the STL until C++23.
Executors
Executors provide a common API for asynchronous and concurrent programming in C++. Related features have been discussed since 2012 and were finalized in 2019 after many revisions. Currently, it is a very simple and user-friendly model that unifies coroutines and threads, directly influencing the style of writing asynchronous code in the future.
Executors were originally intended to be included in C++20, but the standard committee is conservative, and another feature separated from executors had not been validated before, so it was postponed to C++23. Since it has already been a 7-year wait, what’s another 3 years? The unfortunate part is for those features that depend on executors, especially networking.
Given the current high level of completion, executors may be confirmed for inclusion in C++23 within the next few months.
Networking
If executors took over 10 years to have a chance to enter the C++ standard, networking has waited a full 20 years.
Networking is a set of network APIs based on asio, which is the most complete, reliable in code quality, and uniform in coding style among all third-party C++ network libraries (because there is only one author). The author proposed its inclusion in the C++ standard library as early as 2003, and it was only confirmed to be included in the standard library in 2023.
Networking depends on executors, which are now confirmed, so the code for asio will also undergo some changes to encapsulate asynchronous APIs using executors.
In addition to the four new features at the standard library level mentioned above, C++23 may also introduce some new language-level features, depending on the progress of these features. C++23 will strongly recommend the following features, and if any of them are ready, they will be directly included in the C++ standard: Reflection, Pattern matching, and Contracts. Currently, these features are all progressing steadily.
—END—