Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/23"

From cppreference.com
< cpp
m (→‎New language features: +2 examples.)
 
(29 intermediate revisions by 12 users not shown)
Line 1: Line 1:
−
Life sucks !!
+
{{title|C++23}}
 +
{{cpp/version/navbar}}
  
−
Thats what I thought before .....
+
The next generation of the C++ standard.
  
−
But no life does not suck ....
+
See: {{stddoc|P1000R5|The current IS schedule for C++23}} (2023-05-10).
  
 +
{{todo|Check that all significant features are mentioned (using the Compiler Support tables below). Add more links and maybe regroup some lines.}}
  
−
It is one's way of thinking that sucks ....
+
==New language features==
 +
* New [[cpp/feature test#Language features|language feature testing macros]]
 +
* {{ls|cpp/language/function#Explicit object parameter}}, {{lsd|cpp/language/member functions#Explicit object member functions}}, a.k.a. "deducing {{c/core|this}}" ({{stddoc|P0847R7}})
 +
* [[cpp/language/operators#Array subscript operator|Multidimensional subscript operator]] (e.g. {{c|1=v[1, 3, 7] = 42;}}) ({{stddoc|P2128R6}})
 +
* {{c|static operator[]}} ({{stddoc|P2589R1}}), {{c|static operator()}}, and static lambdas ({{stddoc|P1169R4}})
 +
* {{c|auto(x)}} and {{c|auto{x}<!---->}}: [[cpp/language/explicit cast#Syntax|decay-copy]] in the language ({{stddoc|P0849R8}})
 +
* Assumptions via new attribute {{attr|assume|3=(''expression'')}} ({{stddoc|P1774R8}})
 +
* Attributes on [[cpp/language/lambda#Syntax|lambda-expressions]] ({{stddoc|P2173R1}})
 +
* Optional [[cpp/types/floating-point|extended floating-point types]]: {{c/core|std::float{16{{!}}32{{!}}64{{!}}128}_t}}, and {{c/core|std::bfloat16_t}} ({{stddoc|P1467R9}})
 +
* New preprocessor directives: [[cpp/preprocessor/conditional|{{tt|#elifdef}}, {{tt|#elifndef}}]] ({{stddoc|P2334R1}}), and {{ltt|cpp/preprocessor/error|#warning}} ({{stddoc|P2437R1}})
 +
* [[cpp/language/integer literal#The type of the literal|Literal suffix '{{tt|Z}}'/'{{tt|z}}']] for ({{c/core|signed}}) {{c/core|std::size_t}} literals ({{stddoc|P0330R8}}), e.g. {{c|1=auto ouz = 0uz;}}
 +
* White-spaces trimming before line splicing. ({{stddoc|P2223R2}})
 +
* Simpler implicit move ({{stddoc|P2266R3}})
 +
* Extending the lifetime of temporaries in range-based for loop initializer ({{stddoc|P2718R0}})
 +
* CTAD from inherited constructors ({{stddoc|P2582R1}})
 +
* Labels at the end of compound statements ({{stddoc|P2324R2}}), e.g.<br>
 +
: {{c multi|
 +
void f(int& x)|
 +
{|
 +
    if (x)|
 +
        goto END;|
 +
    x {{=}} 42;|
 +
END:|
 +
}<!---->}}
 +
* Alias declarations ({{c/core|using}}) in init-statements ({{stddoc|P2360R0}}), e.g.<br>
 +
: {{c multi
 +
|for (using T {{=}} int; T e : v)
 +
|    /* ... */
 +
}}
 +
* Make {{ttb|()}} more optional for lambda expressions ({{stddoc|P1102R2}})
 +
* Narrowing contextual conversions to {{c/core|bool}} in {{c/core|static_assert}} and {{c/core|if constexpr}} ({{stddoc|P1401R5}})
 +
* Make declaration order layout (of non-static class data members) mandated ({{stddoc|P1847R4}})
 +
* Text encoding changes:
 +
** [[cpp/language/charset|Character sets and encodings]] ({{stddoc|P2314R4}})
 +
** Consistent character literal encoding ({{stddoc|P2316R2}})
 +
** {{ls|cpp/language/escape#Named universal character escapes}}, e.g. {{c|"\N{CAT FACE}"}} for {{c|"🐱"}} ({{stddoc|P2071R2}})
 +
** [[cpp/language/escape|Delimited escape sequences]], e.g. {{c|"\o{7777}"}}, {{c|"\x{C0DE}"}}, {{c|"\u{CAFE}"}} ({{stddoc|P2290R3}})
 +
** [[cpp/language/translation_phases#Phase 1|Support for UTF-8 as a portable source file encoding]] ({{stddoc|P2295R6}})
 +
* {{ltt|cpp/language/if#Consteval if|if consteval}} / {{ltt|cpp/language/if#Consteval if|if not consteval}} ({{stddoc|P1938R3}})
 +
* {{c/core|constexpr}} changes:
 +
** Non-literal variables, labels, and {{c/core|goto}}s in {{c/core|constexpr}} functions ({{stddoc|P2242R3}})
 +
** Permitting {{c/core|static}} and {{c/core|thread_local}} variables in constant expressions in {{c/core|constexpr}} functions ({{stddoc|P2647R1}})
 +
** {{c/core|constexpr}} function does not need its return type and parameter types to be literal type ({{stddoc|P2448R2}})
 +
** {{c/core|constexpr}} function for which no invocation satisfies the requirements of a core constant expression ({{stddoc|P2448R2}})
  
−
change the way we think about these non-sensical problems ... let in the who cares attitude .... and finallly we feel so relieved .... well, atleast in the intial phase....
+
==New library features==
 +
* New [[cpp/feature test#Library features|library feature testing macros]]
 +
===New modules===
 +
* [[cpp/standard library#Importing modules|{{tt|std}} and {{tt|std.compat}}]] ({{stddoc|P2465R3}})
  
 +
===New headers===
 +
* {{header|expected}}
 +
* {{header|flat_map}}
 +
* {{header|flat_set}}
 +
* {{header|generator}}
 +
* {{header|mdspan}}
 +
* {{header|print}}
 +
* {{header|spanstream}}
 +
* {{header|stacktrace}}
 +
* {{header|stdfloat}}
  
 +
C compatibility headers:
 +
* {{header|stdatomic.h}} ({{stddoc|P0943R6}})
  
−
LeTs See HoW maNy more PaGes I CAn rEWriTe ..... buhahahahaha .....
+
===Library features===
 +
=====General Utilities=====
 +
* {{c/core|std::expected}}: a new vocabulary type to return a function's result ({{header|expected}}) ({{stddoc|P0323R12}}, {{stddoc|P2549R1}})
 +
* {{c/core|std::move_only_function}}: a move-only callable wrapper ({{stddoc|P0288R9}})
 +
* {{c/core|std::bind_back}}: a call wrapper ({{stddoc|p2387r3}})
 +
* {{c/core|std::byteswap}}: reverses the bytes ({{stddoc|P1272R4}})
 +
* {{c/core|std::forward_like}} ({{stddoc|P2445R1}})
 +
* {{c/core|std::invoke_r}}: invokes a {{named req|Callable}} object ({{stddoc|p2136r3}})
 +
* {{c/core|std::to_underlying}}: a utility function to get the underlying value of {{c/core|enum}} ({{stddoc|P1682R3}})
 +
* {{c/core|std::unreachable}}: a function to mark unreachable code ({{stddoc|p0627r6}})
 +
* Monadic operations ({{tt|transform}}, {{tt|or_else}}, and {{tt|and_then}}) for {{c/core|std::optional}} ({{stddoc|P0798R8}}) and {{c/core|std::expected}} ({{stddoc|P2505R5}})
 +
* {{c/core|std::tuple}} is compatible with other tuple-like objects ({{stddoc|p2165r4}})
 +
* Adding default arguments for {{c/core|std::pair}}'s forwarding constructor ({{stddoc|p2718r0}})
 +
* {{c/core|std::basic_common_reference}} specialization for {{c/core|std::reference_wrapper}} yielding reference types ({{stddoc|p2655r3}})
  
 +
=====Coroutine Library=====
 +
* {{c/core|std::generator}}: synchronous {{lt|cpp/language/coroutine}} generator for ranges ({{stddoc|P2502R2}}, {{stddoc|P2787R0}})
  
−
ohhhh .... suddenly I feel drunk with Powerr .....
+
=====Diagnostic=====
 +
* {{ls|cpp/utility#Stacktrace}} library ({{stddoc|p0881r7}})
  
−
Controll urself girl .... Power Corrupts ....
+
=====Algorithm, Iterators, and Ranges=====
 +
* New range adaptors:
 +
** {{c/core|views::adjacent}} and {{c/core|views::adjacent_transform}} ({{stddoc|P2321R2}})
 +
** {{c/core|views::as_const}} ({{stddoc|P2278R4}})
 +
** {{c/core|views::as_rvalue}} ({{stddoc|P2446R2}})
 +
** {{c/core|views::cartesian_product}} ({{stddoc|p2374r4}})
 +
** {{c/core|views::chunk_by}} ({{stddoc|P2443R1}})
 +
** {{c/core|views::chunk}} ({{stddoc|P2442R1}})
 +
** {{c/core|views::enumerate}} ({{stddoc|p2164r9}})
 +
** {{c/core|views::join_with}} ({{stddoc|p2441r2}})
 +
** {{c/core|views::repeat}} ({{stddoc|p2474r2}})
 +
** {{c/core|views::slide}} ({{stddoc|P2442R1}})
 +
** {{c/core|views::stride}} ({{stddoc|p1899r3}})
 +
** {{c/core|views::zip}}, {{c/core|views::zip_transform}} ({{stddoc|P2321R2}})
 +
* {{c/core|ranges::range_adaptor_closure}}: a helper for program-defined range adaptor closures ({{stddoc|p2387r3}})
 +
* {{c/core|ranges::to}}: a range conversion function ({{stddoc|p1206r7}})
 +
* New constrained ranges algorithm:
 +
** {{c/core|ranges::starts_with}} and {{c/core|ranges::ends_with}} ({{stddoc|p1659r3}})
 +
** {{c/core|ranges::contains}} and  {{c/core|ranges::contains_subrange}} ({{stddoc|p2302r4}})
 +
** {{c/core|ranges::find_last}}, {{c/core|ranges::find_last_if}}, and {{c/core|ranges::find_last_if_not}} ({{stddoc|p1223r5}})
 +
** {{c/core|ranges::iota}}, {{c/core|ranges::shift_left}}, and {{c/core|ranges::shift_right}}: rangified versions of non-constrained algorithms  ({{stddoc|p2440r1}})
 +
** {{c/core|ranges::fold_left}} etc.: [[cpp/algorithm/ranges#Constrained fold operations|range fold algorithms]] ({{stddoc|p2322r6}})
 +
* Rectifying constant iterators, sentinels, and ranges, that is, {{c/core|ranges::cbegin}} and other similar utilities returning constant iterators should be fully guaranteed even for shallow-{{c/core|const}} views (such as {{c/core|std::span}}) ({{stddoc|p2278r4}})
 +
** Making multi-param constructors of some views explicit ({{stddoc|p2711r1}})
 +
** Ranges iterators as inputs to non-ranges algorithms ({{stddoc|p2408r5}})
 +
** Relaxing range adaptors to allow for move only types ({{stddoc|p2494r2}})
  
−
Just Breate in and Breathe out ..... repeat ... slowly ....
+
=====Containers=====
 +
* {{c/core|std::mdspan}}: a non-owning multidimensional array reference ({{stddoc|P0009R18}}, {{stddoc|P2599R2}}, {{stddoc|P2604R0}}, {{stddoc|P2613R1}}, {{stddoc|P2763R1}})
 +
* Constructibility and assignability of containers from other compatible ranges ({{stddoc|p1206r7}})
 +
* {{c/core|std::flat_set}}, {{c/core|std::flat_multiset}} ({{stddoc|P1222R4}}), {{c/core|std::flat_map}}, {{c/core|std::flat_multimap}} ({{stddoc|P0429R9}}): flat sets and flat maps - container adaptors wrapping underlying sorted random-access containers
 +
* Allowing iterator pair construction in {{c/core|std::stack}} and {{c/core|std::queue}} ({{stddoc|p1425r4}})
 +
* Heterogeneous erasure overloads for associative containers ({{stddoc|p2077r2}})
 +
* Non-deduction context for allocators in container deduction guides ({{stddoc|p1518r2}})
 +
* Requiring {{c/core|std::span}} and {{c/core|std::basic_string_view}} to be trivially copyable ({{stddoc|p2251r1}})
 +
 
 +
=====Compile-time support=====
 +
* {{c/core|constexpr}} support for:
 +
** {{c/core|std::bitset}} ({{stddoc|p2417r2}})
 +
** {{c/core|std::unique_ptr}} ({{stddoc|p2273r3}})
 +
** {{ltt|cpp/types/type_info/operator_cmp|2=std::type_info::operator==}} ({{stddoc|p1328r1}})
 +
** Some {{header|cmath}} functions ({{stddoc|p0533r9}})
 +
** Integral overloads of {{c/core|std::to_chars}} and {{c/core|std::from_chars}} ({{stddoc|p2291r3}})
 +
* [[cpp/meta|Metaprogramming]] utilities:
 +
** Adding move-only types support for comparison concepts ({{stddoc|p2404r3}})
 +
** Type traits:
 +
*** {{c/core|std::is_scoped_enum}} ({{stddoc|p1048r1}})
 +
*** {{c/core|std::is_implicit_lifetime}} ({{stddoc|p2674r1}})
 +
*** {{c/core|std::reference_constructs_from_temporary}}, and {{c/core|std::reference_converts_from_temporary}} ({{stddoc|p2255r2}})
 +
 
 +
=====Memory Management=====
 +
* {{c/core|std::out_ptr}} and {{c/core|std::inout_ptr}}: smart pointer adaptors for C interoperability ({{stddoc|p1132r7}})
 +
* {{c/core|std::allocate_at_least}} and {{c/core|std::allocator::allocate_at_least}} ({{stddoc|p0401r6}})
 +
* {{c/core|std::start_lifetime_as}}: an explicit lifetime management function for implicit-lifetime types ({{stddoc|p2590r2}})
 +
* Disallowing user specialization of {{c/core|std::allocator_traits}} ({{stddoc|p2652r2}})
 +
 
 +
=====String and Text Processing=====
 +
* New member functions and changes in string types:
 +
** {{c/core|std::basic_string::contains}} and {{c/core|std::basic_string_view::contains}} ({{stddoc|p1679r3}})
 +
** Disabling construction from {{c|nullptr}} for {{c/core|std::basic_string}} and {{c/core|std::basic_string_view}} ({{stddoc|p2166r1}})
 +
** Explicit range constructor for {{c/core|std::basic_string_view}} ({{stddoc|p1989r2}})
 +
** {{c/core|std::basic_string::resize_and_overwrite}} ({{stddoc|p1072r10}})
 +
** Rvalue reference overload of {{c/core|std::basic_string::substr}} for efficient slicing ({{stddoc|p2438r2}})
 +
* Formatting ranges, tuples, escaped presentation of characters and strings, {{c/core|std::thread::id}}, and {{lsd|cpp/utility#Stacktrace}}s. ({{stddoc|p2286r8}}) ({{stddoc|p2585r1}}) ({{stddoc|p2693r1}})
 +
 
 +
=====I/O and print=====
 +
* Formatted output functions {{c/core|std::print}} and {{c/core|std::println}} provided in header {{header|print}} ({{stddoc|p2093r14}})
 +
* {{ltt|cpp/spanstream}} library ({{c/core|std::span}}-based string stream) provided in header {{header|spanstream}} ({{stddoc|p0448r4}})
 +
* Support exclusive mode in {{c/core|std::fstreams}} ({{stddoc|p2467r1}})
 +
* Support of printing {{c|volatile T*}}: {{c|std::basic_ostream::operator<<(const volatile void*)}} ({{stddoc|P1147R1}})
 +
 
 +
==Obsolete==
 +
=====Removed=====
 +
* Garbage collection support and reachability-based leak detection. ({{stddoc|P2186R2}})
 +
* Mixed wide string literals {{lsd|cpp/language/string literal#Concatenation}} support, e.g., {{c|1=const auto* no = u"q" U"p"}} is ill-formed. ({{stddoc|P2201R1}})
 +
* Non-encodable wide character literals and multicharacter wide character literals, e.g. {{c|1=wchar_t x = 'db'}} is ill-formed. ({{stddoc|P2362R3}})
 +
 
 +
=====Deprecated=====
 +
* {{c/core|std::aligned_storage}} and {{c/core|std::aligned_union}} ({{stddoc|P1413R3}})
 +
* {{c/core|std::numeric_limits::has_denorm}} ({{stddoc|P2614R2}})
 +
 
 +
=====Reverted deprecations=====
 +
* The {{c|operator,}} (comma operator) in subscript expressions (but the semantics has been changed to support overloadable multidimensional subscript {{c|operator[]}}).
 +
* Some C headers (the corresponding {{tt|<*.h>}} headers for compatibility with C) ({{stddoc|P2340R1}})
 +
 
 +
==Defect reports==
 +
<!--{{cpp/language/history/DR23}}-->
 +
 
 +
==Compiler support==
 +
Main Article: [[cpp/compiler support#C++23 features|C++23 compiler support]]
 +
{{cpp/compiler support/23}}
 +
{{cpp/compiler support/note}}
 +
 
 +
===External links===
 +
{{elink begin}}
 +
{{elink|{{enwiki|C++23}} - Wikipedia}}
 +
{{elink end}}
 +
<!--
 +
* [https://github.com/makelinux/examples/blob/HEAD/cpp/23.cpp Working C++23 examples]
 +
-->
 +
 
 +
{{langlinks|es|ko|ru|zh}}

Latest revision as of 05:59, 23 September 2024

 
C++
 
Versions
 

The next generation of the C++ standard.

See: The current IS schedule for C++23 (2023-05-10).

This section is incomplete
Reason: Check that all significant features are mentioned (using the Compiler Support tables below). Add more links and maybe regroup some lines.

Contents

[edit] New language features

void f(int& x)
{
    if (x)
        goto END;
    x = 42;
END:
}
  • Alias declarations (using) in init-statements (P2360R0), e.g.
for (using T = int; T e : v)
    /* ... */

[edit] New library features

[edit] New modules

[edit] New headers

C compatibility headers:

[edit] Library features

[edit] General Utilities
[edit] Coroutine Library
[edit] Diagnostic
[edit] Algorithm, Iterators, and Ranges
[edit] Containers
[edit] Compile-time support
[edit] Memory Management
[edit] String and Text Processing
[edit] I/O and print

[edit] Obsolete

[edit] Removed
  • Garbage collection support and reachability-based leak detection. (P2186R2)
  • Mixed wide string literals concatenation support, e.g., const auto* no = u"q" U"p" is ill-formed. (P2201R1)
  • Non-encodable wide character literals and multicharacter wide character literals, e.g. wchar_t x = 'db' is ill-formed. (P2362R3)
[edit] Deprecated
[edit] Reverted deprecations
  • The operator, (comma operator) in subscript expressions (but the semantics has been changed to support overloadable multidimensional subscript operator[]).
  • Some C headers (the corresponding <*.h> headers for compatibility with C) (P2340R1)

[edit] Defect reports

[edit] Compiler support

Main Article: C++23 compiler support

[edit] C++23 core language features

C++23 feature

  		Paper(s)

 
GCC
Clang
MSVC
Apple Clang
EDG eccp
Intel C++
IBM XL C++
IBM Open XL C++ for AIX
IBM Open XL C++ for z/OS
Sun/Oracle C++
Embarcadero C++ Builder
Cray
Nvidia HPC C++ (ex PGI)*
Nvidia nvcc
Literal suffix for (signed) size_t P0330R8 11 13

13.1.6*

6.5 2022.2
Make () more optional for lambdas P1102R2 11 13

13.1.6*

6.3 2022.2
if consteval P1938R3 12 14

14.0.0*

6.3 2022.2
Removing Garbage Collection Support P2186R2 12 N/A 19.30* N/A
Narrowing contextual conversions in static_assert and constexpr if P1401R5 9 13 (partial)*
14

14.0.0*

2022.2
Trimming whitespaces before line splicing P2223R2 Yes Yes Yes 2022.2
Make declaration order layout mandated P1847R4 Yes Yes Yes Yes 2022.2
Removing mixed wide string literal concatenation P2201R1 Yes Yes Yes Yes Yes Yes
Explicit object member functions (deducing this) P0847R7 14 18
19* 		19.32*
(partial)* 		6.3
auto(x) and auto{x} P0849R8 12 15

14.0.3*

6.4 2022.2
#elifdef and #elifndef P2334R1 12 13 19.40*

13.1.6*

6.5 2022.2
Non-literal variables (and labels and gotos) in constexpr functions P2242R3 12 15

14.0.3*

6.3 2022.2
Consistent character literal encoding P2316R2 Yes Yes 19.30* Yes Yes 2022.2
Character sets and encodings P2314R4 10 Yes Yes 2022.2
Extend init-statement (of for loop) to allow alias-declaration P2360R0 12 14

14.0.0*

2022.2
Multidimensional subscript operator P2128R6 12 15

14.0.3*

2022.2
Attributes on lambdas P2173R1 9 13

13.1.6*

6.6 2022.2
#warning P2437R1 Yes* Yes

15.0.0*

6.5 2023.2
Remove non-encodable wide character literals and multicharacter wide character literals P2362R3 13 14

15.0.0*

2023.2
Labels at the end of compound statements P2324R2 13 16 6.5 2023.2
Delimited escape sequences P2290R3 13 15

15.0.0*

2023.2
Named universal character escapes P2071R2 13 15

15.0.0*

6.7 2023.2
Relaxing some constexpr restrictions P2448R2 13 17 (partial)
19 		2024.0 (partial)
Simpler implicit move P2266R3 13 13 2022.2
static operator() P1169R4 13 16 2023.2
Requirements for optional extended floating-point types P1467R9 13 N/A 6.4
Class template argument deduction from inherited constructors P2582R1 14
Attribute [[assume]] P1774R8 13 19
Support for UTF-8 as a portable source file encoding P2295R6 13* 15* 19.0 (Update 2)**

15.0.0*

2023.2
static operator[] P2589R1 13 16 6.7 2023.2
Permitting static constexpr variables in constexpr functions P2647R1 13 16 2023.2
Extending the lifetime of temporaries in range-based for loop initializer P2718R0 15 19


DR11: Change scope of lambda trailing-return-type P2036R3
P2579R0 		17 2023.2
DR20: Meaningful exports P2615R1 15 17 (partial)
DR20: consteval needs to propagate up P2564R0 14 17 2024.0
DR98: C++ Identifier Syntax using Unicode Standard Annex 31 P1949R7 12 14

14.0.0*

6.4 2022.2
DR11: Allow duplicate attributes P2156R1 11 13

13.1.6*

6.5
DR20: Adjusting the value of feature-test macro __cpp_concepts P2493R0 12 19.32* 6.4
DR98: Relax requirements on wchar_t to match existing practices P2460R2 Yes Yes

15.0.0*

2023.2
DR11: Using unknown pointers and references in constant expressions P2280R4 14
DR20: The Equality Operator You Are Looking For P2468R2 13 16 2023.2
DR20: char8_t Compatibility and Portability Fix P2513R4 13 16 19.34* 2023.2
DR98/11: Clarify reporting of diagnostic directives and allow static_assert of non-value-dependent expressions in a template context CWG2518 13 17 16.0*
(partial)*
19.40*
 

C++23 feature 		 

Paper(s)
GCC
Clang
MSVC
Apple Clang
EDG eccp
Intel C++
IBM XL C++
IBM Open XL C++ for AIX
IBM Open XL C++ for z/OS
Sun/Oracle C++
Embarcadero C++ Builder
Cray
Nvidia HPC C++ (ex PGI)*
Nvidia nvcc

[edit] C++23 library features

C++23 feature

  		Paper(s)

 
GCC libstdc++
Clang libc++
MSVC STL
Apple Clang*
IBM Open XL C/C++ for AIX*
Sun/Oracle C++*
Embarcadero C++ Builder*
Stacktrace library P0881R7
P2301R1 		12 (partial)*
14* 		19.34*
<stdatomic.h> P0943R6 12 15 19.31*

14.0.3*

std::is_scoped_enum P1048R1 11 12 19.30*

13.0.0*

std::basic_string::contains(), std::basic_string_view::contains() P1679R3 11 12 19.30*

13.0.0*

std::to_underlying P1682R3 11 13 19.30*

13.1.6*

Relaxing requirements for time_point<>::clock P2212R2 N/A N/A N/A N/A
Providing size feedback in the Allocator interface P0401R6 15 19.30*

14.0.3*

<spanstream>: string-stream with std::span-based buffer P0448R4 12 19.31*
std::out_ptr(), std::inout_ptr() P1132R8 14 19 19.30*
constexpr type_info::operator==() P1328R1 12 17 19.33**
19.34*

15.0.0*

Iterator pair constructors for std::stack and std::queue P1425R4 12 14 19.31*

14.0.3*

Non-deduction context for allocators in container deduction guides P1518R2 12* 13* 19.31**

13.1.6**

ranges::starts_with() and ranges::ends_with() P1659R3 17 (partial)*
18 		19.31*
Prohibiting std::basic_string and std::basic_string_view construction from nullptr P2166R1 12 13 19.30*

13.1.6*

std::invoke_r() P2136R3 12 17 19.31*

15.0.0*

Range constructor for std::basic_string_view P1989R2 11 14 19.30*

14.0.3*

Default template arguments for std::pair's forwarding constructor P1951R1 14 14 19.30*

14.0.3*

Remove Garbage Collection and Reachability-Based Leak Detection (library support) P2186R2 12 14 19.30*

14.0.3*

zip: views::zip, views::zip_transform, views::adjacent, and views::adjacent_transform P2321R2 13 15 (partial)* 19.33*(partial)***
19.37*

14.0.3*

Heterogeneous erasure overloads for associative containers P2077R3 19.32*
std::byteswap() P1272R4 12 14 19.31*

14.0.3*

Printing volatile T* P1147R1 11.3 14 19.31*

14.0.3*

basic_string::resize_and_overwrite() P1072R10 12 14 19.31*

14.0.3*

Monadic operations for std::optional P0798R8 12 14 19.32*

14.0.3*

std::move_only_function P0288R9 12 19.32*
Add a conditional noexcept specification to std::exchange P2401R0 12 14 19.25*

14.0.3*

Require std::span & std::basic_string_view to be TriviallyCopyable P2251R1 Yes Yes Yes Yes
Clarifying the status of the “C headers” P2340R1 Yes Yes Yes Yes
<expected> P0323R12
P2549R1 		12 16 19.33*

15.0.0*

constexpr for <cmath> and <cstdlib> P0533R9 4.6 (partial)*
std::unreachable() P0627R6 12 15 19.32*

14.0.3*

Deprecating std::aligned_storage and std::aligned_union P1413R3 13 16 19.33*
std::reference_constructs_from_temporary & std::reference_converts_from_temporary P2255R2 13 (partial)*
14 		19
constexpr std::unique_ptr P2273R3 12 16 19.33*

15.0.0*

Constructing containers and strings from ranges with ranges::to(), tagged constructors, insert and assign member functions P1206R7 14 (partial)* 17 19.34*

15.0.0*

Pipe support for user-defined range adaptors (ranges::range_adaptor_closure, std::bind_back) P2387R3 13 (partial)*
14 		19 19.34*
ranges::iota(), ranges::shift_left(), and ranges::shift_right() P2440R1 13 (partial)* 19.34*
views::join_with P2441R2 13 19.34*
views::chunk and views::slide P2442R1 13 19.33*
views::chunk_by P2443R1 13 18 19.33*
std::mdspan: a non-owning multidimensional array reference P0009R18
P2599R2
P2604R0
P2613R1
P2763R1 		17 (partial)*
18 		19.39*

15.0.0*

<flat_map> P0429R9 20 (partial)*
<flat_set> P1222R4
ranges::find_last(), ranges::find_last_if(), and ranges::find_last_if_not() P1223R5 13 19 19.36*
Freestanding Library: Easy <utility>, <ranges>, and <iterator> P1642R11 13* N/A
views::stride P1899R3 13 19.34*
Compatibility between std::tuple and tuple-like objects P2165R4 14 2.9 (partial)* 19.36* (partial)*
19.37* 		partial*
Rectifying constant iterators, sentinels, and ranges. views::as_const P2278R4 13 19.35* (partial)*
19.36*
Formatting Ranges P2286R8 16 19.37*(partial)*
19.39*(partial)*
19.41*(partial)*
19.42*

15.0.0*

Improve default container formatting P2585R1 16 (partial)*
17 		19.42*

15.0.0*

Formatted output library <print> P2093R14
P2539R4 		14 17 (partial)*
18 		19.37*

15.0.0**

Formatting std::thread::id and std::stacktrace P2693R1 14 17 (partial)* 19.38*

15.0.0*

constexpr for integral overloads of std::to_chars() and std::from_chars(). P2291R3 13 16 19.34*

15.0.0*

ranges::contains() and ranges::contains_subrange() P2302R4 13 19 19.34*
Ranges fold algorithms P2322R6 13 19.35*
views::cartesian_product P2374R4
P2540R1 		13 19.37*
Adding move-only types support for comparison concepts (equality_comparable, totally_ordered, three_way_comparable) P2404R3 19.36*
Ranges iterators as inputs to non-ranges algorithms P2408R5 19.34*
constexpr std::bitset P2417R2 13 16 19.34*

15.0.0*

basic_string::substr() && P2438R2 16 19.34*

15.0.0*

views::as_rvalue P2446R2 13 16 19.34*

15.0.0*

Standard Library Modules P2465R3 17 (partial)* 19.35*
(partial)*
19.36*
std::forward_like() P2445R1 14 16 19.34*

15.0.0*

Support exclusive mode for std::fstream P2467R1 12 18 19.36*
views::repeat P2474R2 13 17 19.36*

15.0.0*

Relaxing range adaptors to allow for move-only types P2494R2 14 17 19.34*

15.0.0*

std::basic_string_view range constructor should be explicit P2499R0 12.2 16 19.34*

15.0.0*

std::generator: synchronous coroutine generator for ranges P2502R2
P2787R0 		14 19.43*
Add a conditional noexcept specification to std::apply P2517R1 10 18 19.34*
Explicit lifetime management (std::start_lifetime_as) P2590R2
P2679R2
Clarify handling of encodings in localized formatting of chrono types P2419R2 15* 19.34**
std::move_iterator should not always be input_iterator P2520R0 12.3* 17* 19.34**

15.0.0*

Deduction guides update for explicit object parameter call operators LWG3617 14 19.34*
Deduction guides update for static operator() P1169R4 13 16 19.39*

15.0.0*

Standard names and library support for extended floating-point types P1467R9 13 19.37**
Monadic operations for std::expected P2505R5 13 17 19.36*

15.0.0*

views::enumerate P2164R9 13 19.37*
std::is_implicit_lifetime P2674R1 20
std::common_reference_t of std::reference_wrapper should be a reference type P2655R3 19.37*
Disallowing user specialization of std::allocator_traits P2652R2 19 19.37*
Deprecating std::numeric_limits::has_denorm P2614R2 18 19.37*
Making Multi-Param Constructors Of views explicit P2711R1 17 (partial)* 19.36**

15.0.0*

DR20: Relaxing Ranges Just A Smidge P2609R3 15 20 19.37*
DR20: Stashing Stashing Iterators For Proper Flattening P2770R0 14 18 19.37*
DR17: std::visit() for classes derived from std::variant P2162R2 11.3 13 19.20**
19.30*

13.1.6*

DR20: Conditionally borrowed ranges P2017R1 11 16 19.30*
DR20: Repairing input range adaptors and std::counted_iterator P2259R1 12 19.30*(partial)*
19.31*
DR20: views::join should join all views of ranges P2328R1 11.2 15 19.30*

14.0.3*

DR20: view does not require default_initializable P2325R3 11.3 16 19.30*

15.0.0*

DR20: Range adaptor objects bind arguments by value P2281R1 11 14 19.29 (16.10)*
(partial)*
19.31*

14.0.3*

DR20: constexpr for std::optional and std::variant P2231R1 11.3 (partial)*
12 		13 (partial)*
19 		19.31*

13.1.6* (partial)

DR20: views::lazy_split and redesigned views::split P2210R2 12 16 19.31*

15.0.0*

DR20: Fix ranges::istream_view P2432R1 12 16 19.31*

15.0.0*

DR20: view with ownership P2415R2 12 14 19.31*

14.0.3*

DR20: Fixing locale handling in chrono formatters P2372R3 13 19.31*
DR20: Cleaning up integer-class types P2393R1 19.32*
DR20: std::format() improvements P2216R3 13 14 (partial)*
15 		19.32*

14.0.3*

DR20: Add support for non-const-formattable types to std::format P2418R2 13 15 19.32*

14.0.3*

DR20: std::basic_format_string P2508R1 13 15 19.35*

14.0.3*

DR20: Poison Pills are Too Toxic P2602R2 14 19 19.36*
DR20: std::format fill character allowances P2572R1 14 17 19.37*
DR20: Improving std::format's width estimation P2675R1 14 17 19.38*
DR20: std::barrier's phase completion guarantees P2588R3 19.28 (16.8)**
19.36*
 

C++23 feature 		 

Paper(s)
GCC libstdc++
Clang libc++
MSVC STL
Apple Clang*
IBM Open XL C/C++ for AIX*
Sun/Oracle C++*
Embarcadero C++ Builder*

* - hover over a cell marked with the star * to see additional pop-up notes.
DRnn - the number nn after "DR" denotes target C++ revision the Defect Report is applied to, e.g., DR20 → C++20.

[edit] External links

  C++23 - Wikipedia
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/23&oldid=176382"