\infannex{diff}{Compatibility}

\rSec1[diff.cpp26]{\Cpp{} and ISO \CppXXVI{}}

\rSec2[diff.cpp26.general]{General}

\indextext{summary!compatibility with ISO \CppXXVI{}}%

Subclause \ref{diff.cpp26} lists the differences between \Cpp{} and

ISO \CppXXVI{},

by the chapters of this document.

\rSec2[diff.cpp26.basic]{\ref*{basic}: basics}

\diffref{basic.stc.dynamic.deallocation}

Potentially throwing exception specifications

on deallocation functions are ill-formed.

Removes potential undefined behavior.

Valid \CppXXVI{} code that declares a deallocation function

with a potentially throwing exception specification

becomes ill-formed.

\begin{example}

\begin{codeblock}

struct T {

void operator delete(void *) noexcept(false); // ill-formed; previously well-formed

};

\end{codeblock}

\end{example}

\rSec2[diff.cpp26.dcl]{\ref*{dcl}: declarations}

\diffref{dcl.init}

Support for designated initialization of base classes of aggregates.

New functionality.

Some valid \CppXXVI{} code may fail to compile.

\begin{example}

\begin{codeblock}

struct A { int a; };

struct B : A { int b; };

void f(A); // \#1

void f(B); // \#2

void g() {

f({.a=1}); // ambiguous between \#1 and \#2; previously called \#1

}

\end{codeblock}

\end{example}

\diffref{dcl.fct.def.default}

It is no longer valid

for explicitly defaulted assignment operators to have a

\grammarterm{cv-qualifier-seq} or \tcode{\&\&} \grammarterm{ref-qualifier}, or

for an explicitly defaulted move assignment operator

to have a parameter of type ``reference to \tcode{T}''

where \tcode{T} is cv-qualified.

Removal of rarely-used and confusing feature.

A valid \CppXXVI{} program

which uses these features on an explicitly defaulted assignment operator

is ill-formed.

\begin{example}

\begin{codeblock}

struct S {

S& operator=(const S&) && = default; // ill-formed; previously well-formed

};

struct T {

T& operator=(const T&) const = default; // ill-formed; previously well-formed but deleted

};

struct U {

U& operator=(const U&&) = default; // ill-formed; previously well-formed but deleted

};

\end{codeblock}

\end{example}

\rSec1[diff.cpp23]{\Cpp{} and ISO \CppXXIII{}}

\rSec2[diff.cpp23.general]{General}

\indextext{summary!compatibility with ISO \CppXXIII{}}%

Subclause \ref{diff.cpp23} lists the differences between \Cpp{} and

ISO \CppXXIII{},

by the chapters of this document.

\rSec2[diff.cpp23.lex]{\ref*{lex}: lexical conventions}

\diffref{lex.operators}

New operator \tcode{\caret\caret}.

Required for new features.

Valid \CppXXIII{} code that contains two consecutive \tcode{\caret} tokens

can be ill-formed in this revision of \Cpp{}.

\begin{example}

\begin{codeblock}

struct C { int operator^(int); };

int operator^(int (C::*p)(int), C);

int i = &C::operator^^C{}; // ill-formed; previously well-formed

\end{codeblock}

\end{example}

\diffref{lex.key}

New keywords.

Required for new features.

\begin{itemize}

The \keyword{contract_assert} keyword

is added to introduce a contract assertion

through an \grammarterm{assertion-statement}\iref{stmt.contract.assert}.

\end{itemize}

Valid \CppXXIII{} code using \keyword{contract_assert} as an identifier

is not valid in this revision of \Cpp{}.

\rSec2[diff.cpp23.expr]{\ref*{expr}: expressions}

\diffref{expr.arith.conv}

Operations mixing a value of an enumeration type and a value of a different

enumeration type or of a floating-point type are no longer valid.

Reinforcing type safety.

A valid \CppXXIII{} program that performs operations mixing a value of an

enumeration type and a value of a different enumeration type or of a

floating-point type is ill-formed.

\begin{example}

\begin{codeblock}

enum E1 { e };

enum E2 { f };

bool b = e <= 3.7; // ill-formed; previously well-formed

int k = f - e; // ill-formed; previously well-formed

auto x = true ? e : f; // ill-formed; previously well-formed

\end{codeblock}

\end{example}

\diffref{expr.rel,expr.eq}

Comparing two objects of array type is no longer valid.

The old behavior was confusing since it compared not the contents of the two

arrays, but their addresses.

A valid \CppXXIII{} program directly comparing two array objects is rejected as

ill-formed in this document.

\begin{example}

\begin{codeblock}

int arr1[5];

int arr2[5];

bool same = arr1 == arr2; // ill-formed; previously well-formed

bool idem = arr1 == +arr2; // compare addresses

bool less = arr1 < +arr2; // compare addresses, unspecified result

\end{codeblock}

\end{example}

\diffref{expr.delete}

Calling \tcode{delete} on a pointer to an incomplete class is ill-formed.

Reduce undefined behavior.

A valid \CppXXIII{} program that calls \tcode{delete} on an incomplete

class type is ill-formed.

\begin{example}

\begin{codeblock}

struct S;

void f(S *p) {

delete p; // ill-formed; previously well-formed

}

struct S {};

\end{codeblock}

\end{example}

\rSec2[diff.cpp23.dcl.dcl]{\ref*{dcl}: declarations}

\diffref{dcl.init.list}

Pointer comparisons between \tcode{initializer_list} objects' backing arrays

are unspecified.

Permit the implementation to store backing arrays in static read-only memory.

Valid \CppXXIII{} code

that relies on the result of pointer comparison between backing arrays

may change behavior.

\begin{example}

\begin{codeblock}

bool ne(std::initializer_list<int> a, std::initializer_list<int> b) {

return a.begin() != b.begin() + 1;

}

bool b = ne({2,3}, {1,2,3}); // unspecified result; previously \tcode{false}

\end{codeblock}

\end{example}

\diffref{dcl.array}

Previously, \tcode{T...[n]} would declare a pack of function parameters.

\tcode{T...[n]} is now a \grammarterm{pack-index-specifier}.

Improve the handling of packs.

Valid \CppXXIII{} code that declares a pack of parameters

without specifying a \grammarterm{declarator-id} becomes ill-formed.

\begin{example}

\begin{codeblock}

template <typename... T>

void f(T... [1]);

template <typename... T>

void g(T... ptr[1]);

int main() {

f<int, double>(nullptr, nullptr); // ill-formed,

// previously \tcode{void f<int, double>(int [1], double [1])}

g<int, double>(nullptr, nullptr); // ok

}

\end{codeblock}

\end{example}

\diffref{dcl.attr.grammar}

New token \tcode{:]}.

Required for new features.

Valid \CppXXIII{} code that contained an \grammarterm{attribute-specifier}

with an \grammarterm{attribute-using-prefix}

but no attributes and no whitespace is ill-formed in this revision of \Cpp{}.

\begin{example}

\begin{codeblock}

struct [[using CC:]] C; // ill-formed; previously well-formed

struct [[using DD: ]] D; // OK

\end{codeblock}

\end{example}

\rSec2[diff.cpp23.temp]{\ref*{temp}: templates}

\diffref{temp.constr}

Some atomic constraints become fold expanded constraints.

Permit the subsumption of fold expressions.

Valid \CppXXIII{} code may become ill-formed.

\begin{example}

\begin{codeblock}

template <typename ...V> struct A;

struct S {

static constexpr int compare(const S&) { return 1; }

};

template <typename ...T, typename ...U>

void f(A<T ...> *, A<U ...> *)

requires (T::compare(U{}) && ...); // was well-formed (atomic constraint of type \tcode{bool}),

// now ill-formed (results in an atomic constraint of type \tcode{int})

void g(A<S, S> *ap) {

f(ap, ap);

}

\end{codeblock}

\end{example}

\diffref{temp.deduct.call}

Template argument deduction from overload sets succeeds in more cases.

Allow consideration of constraints to disambiguate overload sets

used as parameters in function calls.

Valid \CppXXIII{} code may become ill-formed.

\begin{example}

\begin{codeblock}

template <typename T>

void f(T &&, void (*)(T &&));

void g(int &); // \#1

inline namespace A {

void g(short &&); // \#2

}

inline namespace B {

void g(short &&); // \#3

}

void q() {

int x;

f(x, g); // ill-formed; previously well-formed, deducing \tcode{T = int\&}

}

\end{codeblock}

There is no change to the applicable deduction rules for

the individual \tcode{g} candidates:

Type deduction from \#1 does not succeed;

type deductions from \#2 and \#3 both succeed.

\end{example}

\rSec2[diff.cpp23.cpp]{\ref*{cpp}: preprocessing directives}

\diffref{cpp.replace.general}

Additional restrictions on macro names.

Avoid hard to diagnose or non-portable constructs.

Keywords,

names of identifiers with special meaning\iref{lex.name},

and (unless otherwise specified) \grammarterm{attribute-token}{s}

specified in \ref{dcl.attr}

may not be used as macro names.

For example, valid \CppXXIII{} code that

defines \tcode{post} or \tcode{pre} as macros

is invalid in this revision of \Cpp{}.

\rSec2[diff.cpp23.library]{\ref*{library}: library introduction}

\diffref{headers}

New headers.

New functionality.

The following \Cpp{} headers are new:

\libheaderrefx{contracts}{support.contract},

\libheaderref{debugging},

\libheaderrefx{hazard_pointer}{hazard.pointer.syn},

\libheaderref{hive},

\libheaderrefx{inplace_vector}{inplace.vector.syn},

\libheaderref{linalg},

\libheaderref{meta},

\libheaderref{rcu},

\libheaderref{simd},

\libheaderref{stdbit.h},

\libheaderref{stdckdint.h}, and

\libheaderrefx{text_encoding}{text.encoding.syn}.

Valid \CppXXIII{} code that \tcode{\#include}{s} headers with these names may be

invalid in this revision of \Cpp{}.

\rSec2[diff.cpp23.mem]{\ref*{mem}: memory management library}

\diffref{c.malloc}

Calling \tcode{realloc} with a non-null pointer and zero size

has erroneous behavior.

The C standard library does not define this behavior.

Valid \CppXXIII{} code that calls \tcode{realloc}

with a non-null pointer and a size of zero is erroneous and may change behavior.

\rSec2[diff.cpp23.strings]{\ref*{strings}: strings library}

\diffref{string.conversions}

Output of floating-point overloads of \tcode{to_string} and \tcode{to_wstring}.

Prevent loss of information and improve consistency with other formatting

facilities.

\tcode{to_string} and \tcode{to_wstring} function calls that take

floating-point arguments may produce a different output.

\begin{example}

\begin{codeblock}

auto s = std::to_string(1e-7); // \tcode{"1e-07"}

// previously \tcode{"0.000000"} with \tcode{'.'} possibly

// changed according to the global C locale

\end{codeblock}

\end{example}

\rSec2[diff.cpp23.io]{\ref*{input.output}: input/output library}

\diffref{istream.unformatted}

Overloaded \tcode{std::basic_istream<char, traits>::ignore}.

Allow \tcode{char} values to be used as delimiters.

Calls to \tcode{istream::ignore} with a second argument of \tcode{char} type

can change behavior.

Calls to \tcode{istream::ignore} with a second argument that is neither

\tcode{int} nor \tcode{char} type can become ill-formed.

\begin{example}

\begin{codeblock}

std::istringstream in("\xF0\x9F\xA4\xA1 Clown Face");

in.ignore(100, '\xA1'); // ignore up to \tcode{'\textbackslash{}xA1'} delimiter,

// previously might have ignored to EOF

in.ignore(100, -1L); // ambiguous overload,

// previously equivalent to \tcode{(int)-1L}

\end{codeblock}

\end{example}

\rSec2[diff.cpp23.depr]{\ref*{depr}: compatibility features}

Remove the type alias \tcode{allocator<T>::is_always_equal}.

Non-empty allocator classes derived from \tcode{allocator} needed to explicitly

define an \tcode{is_always_equal} member type so that \tcode{allocator_traits}

would not use the one from the allocator base class.

It is simpler to correctly define an allocator class with an allocator base

class.

\begin{example}

\begin{codeblock}

template <class T>

struct MyAlloc : allocator<T> {

int tag;

};

static_assert(!allocator_traits<MyAlloc<int>>::is_always_equal); // Error in \CppXXIII{},

// OK in \CppXXVI{}

\end{codeblock}

\end{example}

Removal of atomic access API for \tcode{shared_ptr} objects.

The old behavior was brittle. \tcode{shared_ptr} objects using the old API were

not protected by the type system, and certain interactions with code not using

this API would, in some cases, silently produce undefined behavior. A complete

type-safe replacement is provided in the form of \tcode{atomic<shared_ptr<T>>}.

A valid \CppXXIII{} program that relies on the presence of the removed functions

may fail to compile.

Remove the \tcode{basic_string::reserve()} overload with no parameters.

The overload of \tcode{reserve} with no parameters is redundant.

The \tcode{shrink_to_fit} member function can be used instead.

A valid \CppXXIII{} program that calls \tcode{reserve()}

on a \tcode{basic_string} object may fail to compile.

The old functionality can be achieved by calling \tcode{shrink_to_fit()} instead,

or the function call can be safely eliminated with no side effects.

Remove header \libnoheader{codecvt} and all its contents.

The header has been deprecated for the previous three editions of this document

and no longer implements the current Unicode standard, supporting only the

obsolete UCS-2 encoding.

Ongoing support is at implementer's discretion,

exercising freedoms granted by \ref{zombie.names}.

A valid \CppXXIII{} program \tcode{\#include}-ing the header or importing the

header unit may fail to compile. Code that uses any of the following names by

importing the standard library modules may fail to compile:

\begin{itemize}

\item \tcode{codecvt_mode},

\item \tcode{codecvt_utf16},

\item \tcode{codecvt_utf8},

\item \tcode{codecvt_utf8_utf16},

\item \tcode{consume_header},

\item \tcode{generate_header}, and

\item \tcode{little_endian}.

\end{itemize}

Remove header \libnoheader{strstream} and all its contents.

The header has been deprecated since the original \Cpp{} standard; the

\libheader{spanstream} header provides an updated, safer facility.

Ongoing support is at implementer's discretion,

exercising freedoms granted by \ref{zombie.names}.

A valid \CppXXIII{} program \tcode{\#include}-ing the header or importing the

header unit may become ill-formed. Code that uses any of the following classes

by importing one of the standard library modules may become ill-formed:

\begin{itemize}

\item \tcode{istrstream}

\item \tcode{ostrstream}

\item \tcode{strstream}

\item \tcode{strstreambuf}

\end{itemize}

Remove convenience interfaces \tcode{wstring_convert} and

\tcode{wbuffer_convert}.

These features were underspecified with no clear error reporting mechanism and

were deprecated for the last three editions of this document.

Ongoing support is at implementer's discretion,

exercising freedoms granted by \ref{zombie.names}.

A valid \CppXXIII{} program using these interfaces may become ill-formed.

\rSec1[diff.cpp20]{\Cpp{} and ISO \CppXX{}}

\rSec2[diff.cpp20.general]{General}

\indextext{summary!compatibility with ISO \CppXX{}}%

Subclause \ref{diff.cpp20} lists the differences between \Cpp{} and

ISO \CppXX{},

in addition to those listed above,

by the chapters of this document.

\rSec2[diff.cpp20.lex]{\ref*{lex}: lexical conventions}

\diffref{lex.name}

\indextext{XID_Start}%

\indextext{XID_Continue}%

Previously valid identifiers containing characters

not present in \UAX{44} properties XID_Start or XID_Continue, or

not in Normalization Form C, are now rejected.

Prevent confusing characters in identifiers.

Requiring normalization of names ensures consistent linker behavior.

Some identifiers are no longer well-formed.

\diffref{lex.string}

Concatenated \grammarterm{string-literal}s can no longer have

conflicting \grammarterm{encoding-prefix}es.

Removal of unimplemented conditionally-supported feature.

Concatenation of \grammarterm{string-literal}s

with different \grammarterm{encoding-prefix}es

is now ill-formed.

\begin{example}

\begin{codeblock}

auto c = L"a" U"b"; // was conditionally-supported; now ill-formed

\end{codeblock}

\end{example}

\rSec2[diff.cpp20.expr]{\ref*{expr}: expressions}

\diffref{expr.prim.id.unqual}

Change move-eligible \grammarterm{id-expression}s from lvalues to xvalues.

Simplify the rules for implicit move.

Valid \CppXX{} code that relies on a returned \grammarterm{id-expression}'s

being an lvalue may change behavior or fail to compile.

\begin{example}

\begin{codeblock}

decltype(auto) f(int&& x) { return (x); } // returns \tcode{int\&\&}; previously returned \tcode{int\&}

int& g(int&& x) { return x; } // ill-formed; previously well-formed

\end{codeblock}

\end{example}

\diffref{expr.sub}

Change the meaning of comma in subscript expressions.

Enable repurposing a deprecated syntax to support multidimensional indexing.

Valid \CppXX{} code that uses a comma expression within a

subscript expression may fail to compile.

\begin{example}

\begin{codeblock}

arr[1, 2] // was equivalent to \tcode{arr[(1, 2)]},

// now equivalent to \tcode{arr.operator[](1, 2)} or ill-formed

\end{codeblock}

\end{example}

\rSec2[diff.cpp20.stmt]{\ref*{stmt}: statements}

\diffref{stmt.ranged}

The lifetime of temporary objects in the \grammarterm{for-range-initializer}

is extended until the end of the loop\iref{class.temporary}.

Improve usability of the range-based \keyword{for} statement.

Destructors of some temporary objects are invoked later.

\begin{example}

\begin{codeblock}

void f() {

std::vector<int> v = { 42, 17, 13 };

std::mutex m;

for (int x :

static_cast<void>(std::lock_guard<std::mutex>(m)), v) { // lock released in \CppXX

std::lock_guard<std::mutex> guard(m); // OK in \CppXX, now deadlocks

}

}

\end{codeblock}

\end{example}

\rSec2[diff.cpp20.dcl]{\ref*{dcl}: declarations}

\diffref{dcl.init.string}

UTF-8 string literals may initialize arrays of \keyword{char} or

\tcode{\keyword{unsigned} \keyword{char}}.

Compatibility with previously written code that conformed to previous versions of this document.

Arrays of \keyword{char} or \tcode{\keyword{unsigned} \keyword{char}}

may now be initialized with a UTF-8 string literal.

This can affect initialization that includes arrays

that are directly initialized within class types, typically aggregates.

\begin{example}

\begin{codeblock}

struct A {

char8_t s[10];

};

struct B {

char s[10];

};

void f(A);

void f(B);

int main() {

f({u8""}); // ambiguous

}

\end{codeblock}

\end{example}

\rSec2[diff.cpp20.over]{\ref*{over}: overloading}

\diffref{over.match.class.deduct}

Deducing class template arguments from inherited constructors.

Making class template argument deduction consistent with construction.

Valid ISO \CppXX{} code may become ill-formed or change meaning

in this revision of \Cpp{}.

\begin{example}

\begin{codeblock}

template<typename T>

struct B {

B(T);

};

template<typename T>

struct D : B<T *> {

D(T);

using B<T *>::B;

T m = "a"; // \#1

};

D d(""); // ill-formed at \#1 (\tcode{T} deduced as \tcode{const char});

// previously well-formed (\tcode{T} deduced as \tcode{const char*})

\end{codeblock}

\end{example}

\rSec2[diff.cpp20.temp]{\ref*{temp}: templates}

\diffref{temp.deduct.type}

Deducing template arguments from exception specifications.

Facilitate generic handling of throwing and non-throwing functions.

Valid ISO \CppXX{} code may be ill-formed in this revision of \Cpp{}.

\begin{example}

\begin{codeblock}

template<bool> struct A { };

template<bool B> void f(void (*)(A<B>) noexcept(B));

void g(A<false>) noexcept;

void h() {

f(g); // ill-formed; previously well-formed

}

\end{codeblock}

\end{example}

\rSec2[diff.cpp20.library]{\ref*{library}: library introduction}

\diffref{headers}

New headers.

New functionality.

The following \Cpp{} headers are new:

\libheaderref{expected},

\libheaderrefx{flat_map}{flat.map.syn},

\libheaderrefx{flat_set}{flat.set.syn},

\libheaderref{generator},

\libheaderref{mdspan},

\libheaderref{print},

\libheaderref{spanstream},

\libheaderref{stacktrace},

\libheaderref{stdatomic.h}, and

\libheaderref{stdfloat}.

Valid \CppXX{} code that \tcode{\#include}{s} headers with these names may be

invalid in this revision of \Cpp{}.

\rSec2[diff.cpp20.concepts]{\ref*{concepts}: concepts library}

\diffref{cmp.concept,concept.equalitycomparable,concept.totallyordered}

Replace \tcode{common_reference_with} in \tcode{three_way_comparable_with},

\tcode{equality_comparable_with}, and \tcode{totally_ordered_with}

with an exposition-only concept.

Allow uncopyable, but movable, types to model these concepts.

Valid \CppXX{} code relying on subsumption

with \tcode{common_reference_with}

may fail to compile in this revision of \Cpp{}.

\begin{example}

\begin{codeblock}

template<class T, class U>

requires @\libconcept{equality_comparable_with}@<T, U>

bool attempted_equals(const T&, const U& u); // previously selected overload

template<class T, class U>

requires @\libconcept{common_reference_with}@<const remove_reference_t<T>&, const remove_reference_t<U>&>

bool attempted_equals(const T& t, const U& u); // ambiguous overload; previously

// rejected by partial ordering

bool test(shared_ptr<int> p) {

return attempted_equals(p, nullptr); // ill-formed; previously well-formed

}

\end{codeblock}

\end{example}

\rSec2[diff.cpp20.memory]{\ref*{mem}: memory management library}

\diffref{allocator.traits.general}

Forbid partial and explicit program-defined specializations

of \tcode{allocator_traits}.

Allow addition of \tcode{allocate_at_least} to \tcode{allocator_traits},

and potentially other members in the future.

Valid \CppXX{} code

that partially or explicitly specializes \tcode{allocator_traits}

is ill-formed with no diagnostic required in this revision of \Cpp{}.

\rSec2[diff.cpp20.utilities]{\ref*{utilities}: general utilities library}

\diffref{format}

Signature changes: \tcode{format}, \tcode{format_to}, \tcode{vformat_to},

\tcode{format_to_n}, \tcode{formatted_size}.

Removal of \tcode{format_args_t}.

Improve safety via compile-time format string checks,

avoid unnecessary template instantiations.

Valid \CppXX{} code that

contained errors in format strings or

relied on previous format string signatures or

\tcode{format_args_t} may become ill-formed.

\begin{example}

\begin{codeblock}

auto s = std::format("{:d}", "I am not a number"); // ill-formed,

// previously threw \tcode{format_error}

\end{codeblock}

\end{example}

\diffref{format}

Signature changes: \tcode{format}, \tcode{format_to}, \tcode{format_to_n},

\tcode{formatted_size}.

Enable formatting of views

that do not support iteration when const-qualified and

that are not copyable.

Valid \CppXX{} code that passes bit-fields to formatting functions

may become ill-formed.

\begin{example}

\begin{codeblock}

struct tiny {

int bit: 1;

};

auto t = tiny();

std::format("{}", t.bit); // ill-formed, previously returned \tcode{"0"}

\end{codeblock}

\end{example}

\diffref{format.string.std}

Restrict types of formatting arguments

used as \fmtgrammarterm{width} or \fmtgrammarterm{precision} in

a \fmtgrammarterm{std-format-spec}.

Disallow types that do not have useful or portable semantics as

a formatting width or precision.

Valid \CppXX{} code that passes a boolean or character type as

\fmtgrammarterm{arg-id} becomes invalid.

\begin{example}

\begin{codeblock}

std::format("{:*^{}}", "", true); // ill-formed, previously returned \tcode{"*"}

std::format("{:*^{}}", "", '1'); // ill-formed, previously returned an

// implementation-defined number of \tcode{'*'} characters

\end{codeblock}

\end{example}

\diffref{format.formatter.spec}

Removed the \tcode{formatter} specialization:

\begin{codeblock}

template<size_t N> struct formatter<const charT[N], charT>;

\end{codeblock}

The specialization is inconsistent with the design of \tcode{formatter},

which is intended to be instantiated only with cv-unqualified object types.

Valid \CppXX{} code that instantiated the removed specialization

can become ill-formed.

\rSec2[diff.cpp20.strings]{\ref*{strings}: strings library}

\diffref{string.classes}

Additional rvalue overload for the \tcode{substr} member function and

the corresponding constructor.

Improve efficiency of operations on rvalues.

Valid \CppXX{} code that created a substring

by calling \tcode{substr} (or the corresponding constructor)

on an xvalue expression with type \tcode{S}

that is a specialization of \tcode{basic_string}

may change meaning in this revision of \Cpp{}.

\begin{example}

\begin{codeblock}

std::string s1 = "some long string that forces allocation", s2 = s1;

std::move(s1).substr(10, 5);

assert(s1 == s2); // unspecified, previously guaranteed to be \tcode{true}

std::string s3(std::move(s2), 10, 5);

assert(s1 == s2); // unspecified, previously guaranteed to be \tcode{true}

\end{codeblock}

\end{example}

\rSec2[diff.cpp20.containers]{\ref*{containers}: containers library}

\diffref{associative.reqmts,unord.req}

Heterogeneous \tcode{extract} and \tcode{erase} overloads

for associative containers.

Improve efficiency of erasing elements from associative containers.

Valid \CppXX{} code may fail to compile in this revision of \Cpp{}.

\begin{example}

\begin{codeblock}

struct B {

auto operator<=>(const B&) const = default;

};

struct D : private B {

void f(std::set<B, std::less<>>& s) {

s.erase(*this); // ill-formed; previously well-formed

}

};

\end{codeblock}

\end{example}

\rSec2[diff.cpp20.thread]{\ref*{thread}: concurrency support library}

\diffref{thread.barrier}

In this revision of \Cpp{},

it is implementation-defined whether a barrier's phase completion step runs

if no thread calls \tcode{wait}.

Previously the phase completion step was guaranteed to run on the last thread that calls \tcode{arrive} or \tcode{arrive_and_drop} during the phase.

In this revision of \Cpp{},

it can run on any of the threads that arrived or waited at the barrier

during the phase.

Correct contradictory wording and

improve implementation flexibility for performance.

Valid \CppXX{} code using a barrier might have

different semantics in this revision of \Cpp{}

if it depends on a completion function's side effects occurring exactly once,

on a specific thread running the phase completion step, or

on a completion function's side effects occurring

without \tcode{wait} having been called.

\begin{example}

\begin{codeblock}

auto b0 = std::barrier(1);

b0.arrive();

b0.arrive(); // implementation-defined; previously well-defined

int data = 0;

auto b1 = std::barrier(1, [&] { data++; });

b1.arrive();

assert(data == 1); // implementation-defined; previously well-defined

b1.arrive(); // implementation-defined; previously well-defined

\end{codeblock}

\end{example}

\rSec1[diff.cpp17]{\Cpp{} and ISO \CppXVII{}}

\rSec2[diff.cpp17.general]{General}

\indextext{summary!compatibility with ISO \CppXVII{}}%

Subclause \ref{diff.cpp17} lists the differences between \Cpp{} and

ISO \CppXVII{},

in addition to those listed above,

by the chapters of this document.

\rSec2[diff.cpp17.lex]{\ref*{lex}: lexical conventions}

\diffref{lex.pptoken,module.unit,module.import,cpp.pre,cpp.module,cpp.import}

New identifiers with special meaning.

Required for new features.

Logical lines beginning with

\tcode{module} or \tcode{import} may

be interpreted differently

in this revision of \Cpp{}.

\begin{example}

\begin{codeblock}

class module {};

module m1; // was variable declaration; now \grammarterm{module-declaration}

module *m2; // variable declaration

class import {};

import j1; // was variable declaration; now \grammarterm{module-import-declaration}

::import j2; // variable declaration

\end{codeblock}

\end{example}

\diffref{lex.header}

\grammarterm{header-name} tokens are formed in more contexts.

Required for new features.

When the identifier \tcode{import}

is followed by a \tcode{<} character,

a \grammarterm{header-name} token may be formed.

\begin{example}

\begin{codeblock}

template<typename> class import {};

import<int> f(); // ill-formed; previously well-formed

::import<int> g(); // OK

\end{codeblock}

\end{example}

\diffref{lex.key}

New keywords.

Required for new features.

\begin{itemize}

\indextext{UTF-8}%

The \keyword{char8_t} keyword is added to differentiate

the types of ordinary and UTF-8 literals\iref{lex.string}.

The \tcode{concept} keyword is

added to enable the definition of concepts\iref{temp.concept}.

The \keyword{consteval} keyword is added to

declare immediate functions\iref{dcl.constexpr}.

The \keyword{constinit} keyword is added to

prevent unintended dynamic initialization\iref{dcl.constinit}.

The \keyword{co_await}, \keyword{co_yield}, and \keyword{co_return} keywords are added

to enable the definition of coroutines\iref{dcl.fct.def.coroutine}.

The \tcode{requires} keyword is added

to introduce constraints through a \grammarterm{requires-clause}\iref{temp.pre}

or a \grammarterm{requires-expression}\iref{expr.prim.req}.

\end{itemize}

Valid \CppXVII{} code using

\keyword{char8_t},

\tcode{concept},

\keyword{consteval},

\keyword{constinit},

\keyword{co_await}, \keyword{co_yield}, \keyword{co_return},

or \tcode{requires}

as an identifier is not valid in this revision of \Cpp{}.

\diffref{lex.operators}

New operator \tcode{<=>}.

Necessary for new functionality.

Valid \CppXVII{} code that contains a \tcode{<=} token