C++23

Language

• explicit this object parameter
• if consteval
• multidimensional subscript operator; this operator may be defined with any number of parameters (or even be variadic), allowing for defining a[i, j, k] = x; instead of a[i][j][k] = x;
• static operator() and operator[] functions, and static lambdas
• simplifying implicit move
• auto(x) and auto{x}
• new preprocessor directives:
  • #elifdef and #elifndef
  • #warning
• extending the lifetime of temporaries within the range-initializer of a range-based for loop to the lifetime of the loop
• new standard attribute [[assume(expression)]]
• class template argument deduction from inherited constructors
• labels at the end of compound statements
• alias declarations in init-statements
• integer-literal suffixes z for the corresponding signed integer type and uz or zu for std::size_t (for example, 0z and 15zu)
• extended floating-point types with literals (conditionally supported)
• 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
  • relaxing restrictions on constexpr functions, including permitting a function to be declared constexpr even if no invocation satisfies the requirements for a core constant expression
• narrowing contextual conversions to bool in static_assert and if constexpr
• trimming whitespaces before line splicing
• requiring declaration-order layout for non-static data members, subject to the rules for potentially overlapping subobjects
• 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

Library

Language defect reports

• C++ identifier syntax using Unicode Standard Annex 31
• allowing duplicate attributes
• changing scope of lambda trailing return type
• making the effects of rewritten comparison candidates less disruptive to existing code
• undeprecating volatile compound assignments
• fixing some compatibility and portability issues involving char8_t and UTF-8 string literals
• relaxing requirements on wchar_t to match existing practices
• relaxing restrictions on using certain pointers and references of unknown origin in constant expressions
• introducing immediate-escalating functions, which can become immediate functions under specified conditions
• allowing static_assert(false) 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

Removed features:

• Removed the language and standard-library provisions for garbage-collection support and reachability-based leak detection, including the strict pointer-safety interface. This removes those facilities from the C++ standard but does not prevent C++ programs from using separate garbage-collection libraries.
• Mixed wide-string literal concatenation.
• Non-encodable wide character literals and multicharacter wide character literals.

Deprecated features:

• std::aligned_storage and std::aligned_union
• std::float_denorm_style, std::numeric_limits<T>::has_denorm and std::numeric_limits<T>::has_denorm_loss

Reverted deprecations:

• The use of the comma operator in subscript expressions is no longer deprecated. C++23 also changes the rules for overloaded operator[] so that it can take multiple parameters.
• The corresponding C-compatibility headers with .h suffixes are no longer deprecated, although their use is discouraged in C++-only code where C interoperability is not needed.

November 2020

The WG21 minutes record positive straw polls on the following items at the virtual meeting of 9 November 2020:

• 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>)
• A type trait std::is_scoped_enum
• The header <stdatomic.h>, for interoperability with C atomics

February 2021

The WG21 minutes record positive straw polls on the following items at the virtual meeting of 22 February 2021:

• Removing unnecessary empty parameter list () from lambda expressions.
• Repairing input range adaptors and counted_iterator.
• Relax the requirements for time_point::clock.
• std::visit for classes that are derived from std::variant.
• Clarified the requirements for lockable objects used by the standard threading library.
• Conditionally borrowed ranges.
• std::to_underlying.

June 2021

The WG21 minutes record positive straw polls on the following feature proposals and defect resolutions at the virtual meeting in June 2021:

• 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).
• Selected changes to 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 template arguments for std::pair's forwarding constructor.

October 2021

The WG21 minutes record positive straw polls on the following feature proposals and defect resolutions at the virtual meeting in October 2021:

• 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 preprocessing directives: #elifdef and #elifndef. Both directives were added to C23 (C language update) and GCC 12.
• 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.
• Added the std::pmr::stacktrace alias for std::basic_stacktrace<std::pmr::polymorphic_allocator<std::stacktrace_entry>>.
• 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.
• Revamped specification and use of integer-class types.
• Clarified that the C-compatibility headers remain supported and are no longer deprecated, while their use is discouraged in C++-only code that does not need C interoperability.

February 2022

The WG21 minutes record positive straw polls on the following proposals at the virtual meeting of 7 February 2022:

• 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

July 2022

The WG21 minutes record positive straw polls on the following proposals and defect resolutions at the virtual meeting of 25 July 2022:

• 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.
• Added named universal character escapes, which allow Unicode characters to be referred to by name. For example, U'\N{LATIN CAPITAL LETTER A WITH MACRON}' is equivalent to U'\u0100'.
• Allowed operator() and lambdas to be static.
• Relaxed restrictions on using pointers and references of unknown origin in constant expressions.
• Allowed implementations to support extended floating-point types in addition to the three standard floating-point types. Where supported, the optional header <stdfloat> provides aliases such as std::float16_t, std::float32_t, std::float64_t, std::float128_t and std::bfloat16_t, with corresponding literal suffixes such as f16, f32, f64, f128 and bf16 (and uppercase forms), as well as relevant standard-library overloads.
• Added the [[assume(expression)]] attribute, which lets an implementation assume that the expression is true for optimization purposes; it is not a run-time assertion.
• Required implementations to support UTF-8 encoded source files as a portable source encoding.
• Allowed arrays of char and unsigned char to be initialized from UTF-8 string literals, as a compatibility measure for char8_t.
• Relaxed the requirement for wchar_t to represent all members of the extended character set, accommodating implementations in which wide characters use UTF-16.
• Added std::mdspan, a multidimensional array view analogous to std::span.
• The flat associative-container adaptors std::flat_map, std::flat_multimap, std::flat_set and std::flat_multiset were added to the standard library.
• Added std::print and std::println for formatted output, including output to standard output.
• Added 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.
• Added an rvalue-qualified std::basic_string::substr() && overload, allowing substring extraction from an rvalue string to reuse its storage where applicable.
• Added std::generator, 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.
• Added explicit lifetime-management functions 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.
• Allowing ranges iterators to be used as inputs to non-ranges algorithms.
• Relaxing range adaptors to allow for move-only types.

November 2022

The WG21 minutes record positive straw polls on the following proposals and defect resolutions at the hybrid meeting of 7 November 2022:

• 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 operations for std::expected.
• Synchronize the output of std::print with the underlying stream if the native Unicode API is used.

February 2023

The WG21 minutes record positive straw polls on the following proposals and defect resolutions at the final hybrid meeting of 6–11 February 2023:

• Referencing the Unicode Standard.
• Adjusted the ranges library to account for stashing iterators when flattening nested ranges.
• std::views::enumerate, a range adaptor that yields elements together with their indices.
• making multi-parameter constructors of some views explicit
• relaxing constraints on some range adaptors
• escaping improvements in std::format.
• improving std::format's width estimation
• changing fill-character allowances in std::format
• formatting std::thread::id and stacktraces
• a type trait std::is_implicit_lifetime
• ensuring std::common_reference_t involving std::reference_wrapper can be a reference type
• disallowing user specialization of std::allocator_traits
• the polymorphic-allocator alias std::pmr::generator
• deprecating std::float_denorm_style, std::numeric_limits<T>::has_denorm and std::numeric_limits<T>::has_denorm_loss
• std::barrier's phase-completion guarantees, including changes to which thread may execute the completion step.