C++23 is the informal name for the version of the ISO/IEC 14882 standard for the C++ programming language that followed C++20. The final draft of this version is N4950.^[1][2]

This article has multiple issues. Please help improve it or discuss these issues on the talk page. (Learn how and when to remove these template messages) This article is in list format but may read better as prose. (December 2023) This article relies excessively on references to primary sources. (December 2023) This article may require cleanup to meet Wikipedia's quality standards. The specific problem is: Article reads like a changelog. (February 2023) This article needs to be updated. (March 2024)

In February 2020, at the final meeting for C++20 in Prague, an overall plan for C++23 was adopted:^[3][4] 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,^[5][6] as was the November 2020 meeting in New York^[7][6] and the February 2021 meeting in Kona, Hawaii.^[7] All meetings until November 2022 were virtual while the November 2022 meeting until the final meeting on February 2023 was hybrid.^[7] The standard was technically finalized by WG21 at the hybrid meeting in Issaquah in February 2023.^[8]

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

import std;

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

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

• Concurrency TS v2^[139]

• 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 . ^[140]
• 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. ^[141]

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:^[142]

• 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:^[143]

• Removing unnecessary empty parameter list () from lambda expressions.
• Repairing input range adaptors and counted_iterator.
• Relax the requirements for time_point::clock.^[144]
• std::visit for classes that are derived from std::variant.
• Locks lock lockables.^[145]
• 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:^[146]

• 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:^[147]

• 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.^[148]
• 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>.^[149]
• 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.^[150]
• Revamped specification and use of integer-class types.^[151]
• 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."^[152]

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

• 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:^[154]

• 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:^[155]

• 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.^[156]

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:^[157]

• Referencing the Unicode Standard.^[158]
• Stashing stashing iterators for proper flattening.^[159]
• 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