C++23

This article needs to be updated. Please help update this article to reflect recent events or newly available information. (March 2024)

C++23, formally ISO/IEC 14882:2024,^[1] is the current open standard for the C++ programming language that follows C++20. The final draft of this version is N4950.^[2][3]

In February 2020, at the final meeting for C++20 in Prague, an overall plan for C++23 was adopted:^[4][5] planned features for C++23 were library support for coroutines, a modular standard library, executors, and networking.

The first WG21 meeting focused on C++23 was intended to take place in Varna in early June 2020, but was cancelled due to the COVID-19 pandemic,^[6][7] as was the November 2020 meeting in New York^[8][7] and the February 2021 meeting in Kona, Hawaii.^[8] All meetings until November 2022 were virtual while the November 2022 meeting until the final meeting in February 2023 was hybrid.^[8] The standard was technically finalized by WG21 at the hybrid meeting in Issaquah in February 2023.^[9]

After many library changes applied to the working draft, the new "Hello, world" program will be: [1]

import std;

int main() {
    std::println("Hello, world!");
}

Changes that have been accepted into C++23 include:

• explicit this object parameter^[10]
• if consteval^[11]
• multidimensional subscript operator^[12]
• static call and subscript operators and static lambdas^[13][14]
• simplifying implicit move^[15]
• auto(x) and auto{x}^[16]
• new preprocessor directives:
  • #elifdef and #elifndef^[17]
  • #warning^[18]
• extending the lifetime of some temporaries in range-based for loop^[19]
• new standard attribute [[assume(expression)]]^[20]
• class template argument deduction from inherited constructors^[21]
• labels at the end of the compound statement^[22]
• alias declarations in init-statements^[23]
• literal suffixes for std::size_t and the corresponding signed type^[24]
• extended floating-point types with literals (conditionally supported)^[25]
• optional () from nullary lambda expressions^[26]
• attributes on lambda expressions^[27]
• constexpr changes:
  • non-literal variables, labels, and gotos in constexpr functions^[28]
  • allowing static and thread_local variables that are usable in constant expressions in constexpr functions^[29]
  • constexpr function does not need its return type and parameter types to be literal type
  • it is now possible to write a constexpr function for which no invocation satisfies the requirements of a core constant expression^[30]
• narrowing contextual conversions to bool in static_assert and if constexpr^[31]
• trimming whitespaces before line splicing^[32]
• make declaration order layout mandated^[33]
• delimited escape sequences^[34]
• named universal character escapes^[35]
• text encoding changes:
  • support for UTF-8 as a portable source file encoding^[36]
  • consistent character literal encoding^[37]
  • character sets and encodings^[38]
• New meaning added to some keywords, such as for this.^[39]

• standard library modules std and std.compat^[40]

• synchronous coroutine std::generator for ranges^[41]

• result type std::expected^[42]
• monadic operations for std::optional^[43] and std::expected^[44]
• utility function std::to_underlying to get the underlying value of enum^[45]
• move-only callable wrapper std::move_only_function^[46]
• std::forward_like^[47]
• std::invoke_r^[48]
• std::bind_back^[49]
• std::byteswap^[50]
• std::unreachable: a function to mark unreachable code^[51]
• made std::tuple compatible with other tuple-like objects^[52]
• std::basic_common_reference specialization for std::reference_wrapper yielding reference types^[53]
• adding default arguments for std::pair's forwarding constructor^[54]

• constexpr support for:
  • std::type_info::operator==^[55]
  • std::bitset^[56]
  • std::unique_ptr^[57]
  • for some <cmath> functions^[58]
  • for integral overloads of std::to_chars and std::from_chars^[59]
• metaprogramming utilities:
  • type traits std::is_scoped_enum,^[60] std::is_implicit_lifetime,^[61] std::reference_constructs_from_temporary, and std::reference_converts_from_temporary.^[62]
• adding move-only types support for comparison concepts^[63]

• new range conversion function std::ranges::to^[64]
• new constrained ranges algorithm:
  • std::ranges::starts_with
  • std::ranges::ends_with^[65]
  • std::ranges::contains
  • std::ranges::contains_subrange^[66]
  • std::ranges::find_last and other variants^[67]
  • rangified versions of iota, shift_left, and shift_right^[68]
  • range fold algorithms^[69]
• new std::ranges::range_adaptor_closure, a helper for defining user-defined range adaptor closures^[49]
• new range adaptors:
  • std::views::zip and other variants
  • std::views::adjacent and other variants^[70]
  • std::views::join_with^[71]
  • std::views::slide
  • std::views::chunk^[72]
  • std::views::chunk_by^[73]
  • std::views::as_rvalue^[74]
  • std::views::as_const^[75]
  • std::views::repeat^[76]
  • std::views::stride^[77]
  • std::views::cartesian_product^[78]
  • std::views::enumerate^[79]
• rectifying constant iterators, sentinels, and ranges, that is, std::ranges::cbegin and other similar utilities returning constant iterators should be fully guaranteed even for shallow-const views (such as std::span)^[75]
• ranges iterators as inputs to non-ranges algorithms^[80]
• relaxing range adaptors to allow for move only types^[81]
• making multi-param constructors of some views explicit^[82]

• std::out_ptr and std::inout_ptr for C interoperability^[83]
• std::allocate_at_least and std::allocator::allocate_at_least^[84]
• explicit lifetime management function std::start_lifetime_as for implicit-lifetime types^[85]
• disallowing user specialization of std::allocator_traits^[86]

• new member functions and changes in string types:
  • std::basic_string_view::contains and std::basic_string::contains^[87]
  • disabling construction from nullptr for std::basic_string and std::basic_string_view^[88]
  • explicit range constructor for std::basic_string_view^[89]
  • std::basic_string::resize_and_overwrite^[90]
  • rvalue reference overload of std::basic_string::substr for efficient slicing^[91]
• formatting ranges, tuples, escaped presentation of characters and strings, std::thread::id, and stacktraces.^[92][93][94]

• stacktrace library^[95]

• formatted output functions std::print and std::println from new header <print>^[96]
• spanstream library (std::span-based string stream) from new header <spanstream>^[97]
• a support for exclusive mode in std::fstreams^[98]
• std::basic_ostream::operator<<(const volatile void*)^[99]

• multidimensional-span std::mdspan^{[100][101][102][103]}
• constructability and assignability of containers from other compatible ranges^[64]
• flat set and flat map container adapters^[104][105]
• non-deduction context for allocators in container deduction guides^[106]
• heterogeneous erasure overloads for associative containers^[107]
• allowing iterator pair construction in stack and queue^[108]
• requiring std::span and std::basic_string_view to be trivially copyable^[109]

• new header <stdatomic.h>^[110]

• C++ identifier syntax using Unicode Standard Annex 31^[111]
• allowing duplicate attributes^[112]
• changing scope of lambda trailing return type^[113]
• making overloaded comparison operators less breaking change^[114]
• undeprecating volatile compound assignments^[115][116]
• fixing the compatibility and portability of char8_t^[117]
• relaxing requirements on wchar_t to match existing practices^[118]
• allowing some pointers and references of this or unknown origin in constant expressions^[119]
• introduction of immediate-escalating functions promoted to immediate functions^[120]
• allowing static_assert(false) in uninstantiated template contexts

• changes in ranges library:
  • conditionally borrowed ranges^[121]
  • repairing input range adaptors and std::counted_iterator^[122]
  • relaxing the constraint on std::ranges::join_view^[123]
  • renamed std::ranges::split_view to std::ranges::lazy_split_view and new split_view^[124]
  • removed std::default_initializable constraint from concept std::ranges::view^[125]
  • view with ownership and new std::ranges::owning_view^[126]
  • fixed std::ranges::istream_view^[127]
• changes in text formatting library:
  • std::basic_format_string^[128]
  • compile-time format string checks
  • reducing binary code size of std::format_to^[129]
  • fixing locale handling in chrono formatters^[130]
  • improving width estimation^[131] and fill character allowances of std::format^[132]
  • use of forwarding references in format arguments to allow non-const-formattable types^[133]
• fully constexpr std::variant and std::optional^[134]
• supporting types derived from std::variant in std::visit^[135]

Removed features:

• Garbage Collection Support and (strict) Pointer Safety^[136] (meaning only relaxed pointer safety is to be relied upon^[137]). This minimal garbage collection support (and pointer safety, needed for it), was added to C++11 but no compilers have ever supported it so the support was removed in C++23.^[138] However, that doesn't mean many GC implementations haven't been used, and continue to be used with C++, such as Boehm GC (and it can also just be used for leak detection in leak detection, when in debug mode), and such GC is often implemented in C++, for other languages to use.
• Mixed wide-string literal concatenation.^[139]
• Non-encodable wide character literals and multicharacter wide character literals.^[140]

Deprecated features:

• std::aligned_storage and std::aligned_union^[141]
• std::numeric_limits::has_denorm^[142]

Reverted deprecated features:

• Use of comma operator in subscript expressions was no longer deprecated but the semantics has been changed to support overloadable n-adic operator[].
• C headers (The corresponding <*.h> headers for compatibility with C)

• Concurrency TS v2^{[143][further explanation needed]}

• Clang progressively added partial C++23 support from 2021 in version 13 through to version 18 in 2024, available through the option -std=c++23.^[144]
• GCC added partial, experimental C++23 support in 2021 in version 11 through the option -std=c++2b or -std=c++23 It also has an option to enable GNU extensions in addition to the experimental C++23 support, -std=gnu++2b.^[145]

In the absence of face-to-face WG21 meetings, the following changes were applied after several virtual WG21 meetings, where they were approved by straw polls.

The following were added after the virtual WG21 meeting of 9 November 2020, where they were approved by straw polls:^[146]

• Literal suffixes for std::size_t and the corresponding signed type
• A member function contains for std::basic_string and std::basic_string_view, to check whether or not the string contains a given substring or character
• A stacktrace library (<stacktrace>), based on Boost.Stacktrace
• A type trait std::is_scoped_enum
• The header <stdatomic.h>, for interoperability with C atomics

After the virtual WG21 meeting of 22 February 2021, following features are added where they were approved by straw polls:^[147]

• Removing unnecessary empty parameter list () from lambda expressions.
• Repairing input range adaptors and counted_iterator.
• Relax the requirements for time_point::clock.^[148]
• std::visit for classes that are derived from std::variant.
• Locks lock lockables.^[149]
• Conditionally borrowed ranges.
• std::to_underlying.

After the summer 2021 ISO C++ standards plenary virtual meeting of June 2021, new features and defect reports were approved by straw polls:^[150]

• Consteval if (if consteval).
• Narrowing contextual conversions to bool.
• Allowing duplicate attributes.
• std::span-based string-stream (<spanstream>).
• std::out_ptr() and std::inout_ptr().
• constexpr for std::optional, std::variant, and std::type_info::operator==.
• Iterators pair constructors for std::stack (stack) and std::queue (queue).
• Few changes of the ranges library:
  • Generalized starts_with and ends_with for arbitrary ranges.
  • Renamed split_view to lazy_split_view and new split_view.
  • Relaxing the constraint on join_view.
  • Removing default_initializable constraint from concept view.
  • Range constructor for std::basic_string_view.
• Prohibiting std::basic_string and std::basic_string_view construction from nullptr.
• std::invoke_r.
• Improvements on std::format.
• Adding default arguments for std::pair's forwarding constructor.

After the autumn 2021 ISO C++ standards plenary virtual meeting of October 2021, new features and defect reports were approved by straw polls:^[151]

• Non-literal variables, labels, and gotos in constexpr functions, but still ill-formed to evaluate them at compile-time.
• Explicit this object parameter.
• Changes on character sets and encodings.
• New preprocessors: #elifdef and #elifndef. Both directives were added to C23 (C language update) and GCC 12.^[152]
• Allowing alias declarations in init-statement.
• Overloading multidimensional subscript operator (e.g. arr[1, 2]).
• Decay copy in language: auto(x) or auto{x}.
• Changes in text formatting library:
  • Fixing locale handling in chrono formatters.
  • Use of forwarding references in format arguments to allow std::generator-like types.
• Addition of type alias std::pmr::stacktrace which is equivalent to std::basic_stacktrace<std::pmr::polymorphic_allocator>.^[153]
• Changes in ranges library:
  • Refined definition of a view.
  • Replacing function template std::ranges::istream_view with alias templates std::ranges::istream_view, std::ranges::wistream_view, and customization point object std::views::istream.
  • zip range adaptor family:
    • zip_view
    • zip_transform_view
    • adjacent_view (and std::views::pairwise being equivalent to std::views::adjacent<2>)
    • adjacent_transform_view (and std::views::pairwise_transform being equivalent to std::views::adjacent_transform<2>)
• std::move_only_function.
• Monadic operations for std::optional.
• Member function template std::basic_string::resize_and_overwrite.
• Printing volatile pointers (volatile T*).
• std::byteswap.
• Heterogeneous erasure overloads for associative containers.
• Every specialization of std::span and std::basic_string_view is trivially copyable.
• Adding conditional noexcept specifications to std::exchange.^[154]
• Revamped specification and use of integer-class types.^[155]
• Clarify C headers. "The headers are not useful in code that is only required to be valid C++. Therefore, the C headers should be provided by the C++ standard library as a fully-supported, not deprecated part, but they should also be discouraged for use in code that is not polyglot interoperability code. [..] This proposal makes the C headers no longer deprecated, so there is no formal threat of future removal. The effective discouragement to use the C headers in pure C++ code is now spelled out explicitly as normative discouragement."^[156]

After the virtual WG21 meeting of 7 February 2022, the following features are added where they were approved by straw polls:^[157]

• Allowed attributes on the function call operator of a lambda
• std::expected
• constexpr for cmath and cstdlib
• Function to mark unreachable code
• ranges::to
• A type trait to detect reference binding to temporary
• Making std::unique_ptr constexpr
• Pipe support for user-defined range adaptors
• ranges::iota, ranges::shift_left and ranges::shift_right
• views::join_with
• Windowing range adaptors: views::chunk and views::slide
• views::chunk_by

After the virtual WG21 meeting of 25 July 2022, the following features and defect reports are added where they were approved by straw polls:^[158]

• Made rewriting equality in expressions less of a breaking change.
• Reverted the deprecation of bitwise assignment to volatile variables.
• Added the #warning preprocessor directive.
• Removed non-encodable wide character literals and multicharacter wide character literals.
• Allowed labels to appear at the end of compound statements.
• Added escape sequences delimited with curly braces for octal and hexadecimal numbers and universal character names.
• Allowed constexpr functions to never be constant expressions.
• Simplified some implicit move rules from C++20 and allowed implicit move when returning an rvalue reference.
• Add a way to specify unicode characters by name. For example, U'\N{LATIN CAPITAL LETTER A WITH MACRON}' // Equivalent to U'\u0100'
• Allowed operator() and lambdas to be static.
• Allowed the this pointer and references of unknown origin to appear in constant expressions.
• Allowed implementations to define extended floating-point types in addition to the three standard floating-point types. Added the type aliases std::float16_t, std::float32_t, std::float64_t, std::float128_t, std::bfloat16_t for these extended types accessible through the header <stdfloat>, their corresponding literal suffixes f16 f32 f64 f128 bf16or F16 F32 F64 F128 BF16 and added overloads to various standard library functions that take floats as arguments.
• Added the [[assume(expression)]] attribute which allows the compiler to assume the provided expression is true to allow optimizations.
• Made support for UTF-8 source files mandatory, providing a portable encoding for source files.
• Allowed arrays of char and unsigned char to be initialized with UTF-8 string literals.
• Removed the requirement that wchar_t can encode all characters of the extended character set, in effect allowing UTF-16 to be used for wide string literals.
• Added std::mdspan, a multidimensional array view analogous to std::span.
• flat_map and flat_set were added to the standard library.
• Added the std::print and std::println functions for printing formatted text to stdout.
• Provide the named modules std and std.compat for importing the standard library.
• Added support for exclusive mode fstreams, analogous to the "x" flag in fopen.
• Allowed std::format to handle ranges, tuples, and other containers.
• Added std::forward_like.
• Made std::string::substr use move semantics.
• Added std::generator which implements a coroutine generator that models std::ranges::input_range
• views::cartesian_product, views::repeat, views::stride, views::as_const, views::as_rvalue.
• Added new algorithms: ranges::find_last, ranges::contains, and ranges fold algorithms.
• Made std::tuple compatible with other tuple-like objects.
• Explicit lifetime management for implicit-lifetime types.
• Made std::bitset and integral overloads of std::to_chars and std::from_chars constexpr-compatible.
• Adding move-only types support for comparison concepts.
• Ranges iterators as inputs to non-ranges algorithms.
• Relaxing range adaptors to allow for move-only types.

After the hybrid WG21 meeting of 7 November 2022, the following features and defect reports are added where they were approved by straw polls:^[159]

• Allowed operator[] to be static.
• Allowed static and thread_local variables to appear in constexpr functions if they are usable in constant expressions.
• consteval propagates upwards, that is, certain existing constexpr functions become consteval functions when those functions can already only be invoked during compile time.
• Extended the lifetime of temporaries that appear in the for-range-initializer of a range-based for loop to cover the entire loop.
• Reverted the deprecation of (all, not just bitwise) compound assignment to volatile variables.
• Monadic functions for std::expected.
• Synchronize the output of std::print with the underlying stream if the native Unicode API is used.^[160]

After the final hybrid WG21 meeting of 6-11 February 2023, the following features and defect reports are added where they were approved by straw polls:^[161]

• Referencing the Unicode Standard.^[162]
• Stashing stashing iterators for proper flattening.^[163]
• views::enumerate
• making multi-param constructors of views explicit
• relaxing ranges just a smidge
• escaping improvements in std::format
• improving std::format's width estimation
• std::format fill character allowances
• formatting thread::id and stacktrace
• A type trait std::is_implicit_lifetime
• std::common_reference_t of std::reference_wrapper should be a reference type
• disallowing user specialization of std::allocator_traits
• std::pmr::generator
• deprecating std::numeric_limits::has_denorm
• std::barrier's phase completion guarantees

• Compiler support for C++23 features