C++23

Modern "Hello, world" Example

Features

Language

• explicit this object parameter
• if consteval
• multidimensional subscript operator
• static call and subscript operators and static lambdas
• simplifying implicit move
• auto and auto
• new preprocessor directives:
• *#elifdef and #elifndef
• *#warning
• extending the lifetime of some temporaries in range-based for loop
• new standard attribute assume(expression)
• class template argument deduction from inherited constructors
• labels at the end of the compound statement
• alias declarations in init-statements
• literal suffixes for size_t and the corresponding signed type:
• extended floating-point types with literals
• optional from nullary lambda expressions
• attributes on lambda expressions
• constexpr changes:
• *non-literal variables, labels, and gotos in constexpr functions
• *allowing static and thread_local variables that are usable in constant expressions in constexpr functions
• *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
• narrowing contextual conversions to bool in static_assert and if constexpr
• trimming whitespaces before line splicing
• make declaration order layout mandated
• delimited escape sequences
• named universal character escapes
• text encoding changes:
• *support for UTF-8 as a portable source file encoding
• *consistent character literal encoding
• *character sets and encodings
• New meaning added to some keywords, such as for this.

Library

Standard Library Module Support

• standard library modules std and std.compat

Coroutine Library Support

• synchronous coroutine std::generator for ranges

General Utilities Support

• result type std::expected
• monadic operations for std::optional and std::expected
• utility function std::to_underlying to get the underlying value of enum
• move-only callable wrapper std::move_only_function
• std::forward_like
• std::invoke_r
• std::bind_back
• std::byteswap
• std::unreachable: a function to mark unreachable code
• made std::tuple compatible with other tuple-like objects
• std::basic_common_reference specialization for std::reference_wrapper yielding reference types
• adding default arguments for std::pair's forwarding constructor

Compile-time Support

• constexpr support for:
• *std::type_info::operator
• * std::bitset
• * std::unique_ptr
• * for some functions
• * for integral overloads of std::to_chars and std::from_chars
• metaprogramming utilities:
• *type traits std::is_scoped_enum, std::is_implicit_lifetime, std::reference_constructs_from_temporary, and std::reference_converts_from_temporary.
• adding move-only types support for comparison concepts

Iterators, Ranges, and Algorithm Support

• new range conversion function std::ranges::to
• new constrained ranges algorithm:
• *std::ranges::starts_with
• *std::ranges::ends_with
• *std::ranges::contains
• *std::ranges::contains_subrange
• *std::ranges::find_last and other variants
• *rangified versions of iota, shift_left, and shift_right
• *range fold algorithms
• new std::ranges::range_adaptor_closure, a helper for defining user-defined range adaptor closures
• new range adaptors:
• *std::views::zip and other variants
• *std::views::adjacent and other variants
• *std::views::join_with
• *std::views::slide
• *std::views::chunk
• *std::views::chunk_by
• *std::views::as_rvalue
• *std::views::as_const
• *std::views::repeat
• *std::views::stride
• *std::views::cartesian_product
• *std::views::enumerate
• 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
• ranges iterators as inputs to non-ranges algorithms
• relaxing range adaptors to allow for move only types
• making multi-param constructors of some views explicit

Memory Management Support

• std::out_ptr and std::inout_ptr for C interoperability
• std::allocate_at_least and std::allocator::allocate_at_least
• explicit lifetime management function std::start_lifetime_as for implicit-lifetime types
• disallowing user specialization of std::allocator_traits

String and Text Processing Support

• new member functions and changes in string types:
• *std::basic_string_view::contains and std::basic_string::contains
• *disabling construction from nullptr for std::basic_string and std::basic_string_view
• *explicit range constructor for std::basic_string_view
• *std::basic_string::resize_and_overwrite
• *rvalue reference overload of std::basic_string::substr for efficient slicing
• formatting ranges, tuples, escaped presentation of characters and strings, std::thread::id, and stacktraces.

Diagnostic Support

• stacktrace library, header and class std::stacktrace

I/O Support

• formatted output functions std::print and std::println from new header
• spanstream library from new header
• a support for exclusive mode in std::fstreams

Containers Support

• multidimensional-span std::mdspan
• constructability and assignability of containers from other compatible ranges
• flat set and flat map container adapters
• non-deduction context for allocators in container deduction guides
• heterogeneous erasure overloads for associative containers
• allowing iterator pair construction in stack and queue
• requiring std::span and std::basic_string_view to be trivially copyable

C-Compatibility Support

• new header

Language defect reports

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

Library defect reports

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

Removed features and deprecation

• Garbage Collection Support and Pointer Safety. This minimal garbage collection support, was added to C++11 but no compilers have ever supported it so the support was removed in C++23. However, that doesn't mean many GC implementations haven't been used, and continue to be used with C++, such as Boehm GC, and such GC is often implemented in C++, for other languages to use.
• Mixed wide-string literal concatenation.
• Non-encodable wide character literals and multicharacter wide character literals.

• std::aligned_storage and std::aligned_union
• std::numeric_limits::has_denorm

• 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

Published as Technical Specifications

• Concurrency TS v2

Compiler support

• 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.
• 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.

History

November 2020

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

February 2021

• Removing unnecessary empty parameter list from lambda expressions.
• Repairing input range adaptors and.
• Relax the requirements for.
• for classes that are derived from.
• .
• Conditionally borrowed ranges.
• .

June 2021

• Consteval if.
• Narrowing contextual conversions to.
• Allowing duplicate attributes.
• -based string-stream.
• and.
• [constexpr|] for,, and.
• Iterators pair constructors for and .
• Few changes of the ranges library:
• * Generalized and for arbitrary ranges.
• * Renamed to and new.
• * Relaxing the constraint on.
• * Removing constraint from concept.
• * Range constructor for.
• Prohibiting and construction from [nullptr|].
• .
• Improvements on.
• Adding default arguments for 's forwarding constructor.

October 2021

• Non-literal variables, labels, and gotos in functions, but still ill-formed to evaluate them at compile-time.
• Explicit [this (computer programming)|] object parameter.
• Changes on character sets and encodings.
• New preprocessors: and. Both directives were added to C23 and GCC 12.
• Allowing alias declarations in init-statement.
• Overloading multidimensional subscript operator.
• Decay copy in language: or.
• Changes in text formatting library:
• * Fixing locale handling in chrono formatters.
• * Use of forwarding references in format arguments to allow -like types.
• Addition of type alias which is equivalent to.
• Changes in ranges library:
• * Refined definition of a view.
• * Replacing function template with alias templates,, and customization point object.
• * range adaptor family:
• **
• **
• **
• **
• .
• Monadic operations for.
• Member function template.
• Printing [volatile (computer programming)|] pointers.
• .
• Heterogeneous erasure overloads for associative containers.
• Every specialization of and is trivially copyable.
• Adding conditional specifications to.
• Revamped specification and use of integer-class types.
• 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."

February 2022

• Allowed attributes on the function call operator of a lambda
• for cmath and cstdlib
• Function to mark unreachable code
• A type trait to detect reference binding to temporary
• Making
• Pipe support for user-defined range adaptors
• , and
• Windowing range adaptors: and

July 2022

• Made rewriting equality in expressions less of a breaking change.
• Reverted the deprecation of bitwise assignment to variables.
• Added the 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 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,
• Allowed [operators in C and C++|] and lambdas to be [static (keyword)|].
• 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 , 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 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 and 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.
• and were added to the standard library.
• Added the and functions for printing formatted text to stdout.
• Provide the named modules and 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 which implements a coroutine generator that models
• ,,,,.
• Added new algorithms:,, 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 -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.

November 2022

• Allowed to be.
• Allowed and [thread-local storage|] variables to appear in functions if they are usable in constant expressions.
• [consteval|] propagates upwards, that is, certain existing functions become 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 loop to cover the entire loop.
• Reverted the deprecation of compound assignment to variables.
• Monadic functions for.
• Synchronize the output of with the underlying stream if the native Unicode API is used.

February 2023

• Referencing the Unicode Standard.
• Stashing stashing iterators for proper flattening.views::enumerate
• making multi-param constructors of views explicit
• relaxing ranges just a smidge
• escaping improvements in std::format
• improving std::format's width estimationstd::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