\infannex{diff}{Compatibility}

\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.decl.general}

Introduction of \tcode{trivially_relocatable_if_eligible} and

\tcode{replaceable_if_eligible} as identifiers with special meaning\iref{lex.name}.

Support declaration of trivially relocatable and replaceable types\iref{class.prop}.

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

\begin{example}

\begin{codeblock}

struct C {};

struct C replaceable_if_eligible {}; // was well-formed (new variable \tcode{replaceable_if_eligible})

// now ill-formed (redefines \tcode{C})

\end{codeblock}

\end{example}

\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.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{}.

\diffref{res.on.macro.definitions}

Additional restrictions on macro names.

Avoid hard to diagnose or non-portable constructs.

Names of special identifiers may not be used as macro names.

Valid \CppXXIII{} code that defines \tcode{replaceable_if_eligible} or

\tcode{trivially_relocatable_if_eligible} as macros is 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.containers]{\ref{containers}: containers library}

\diffref{span.overview}

\tcode{span<const T>} is constructible from \tcode{initializer_list<T>}.

Permit passing a braced initializer list to a function taking \tcode{span}.

Valid \CppXXIII{} code that relies on the lack of this constructor

may refuse to compile, or change behavior in this revision of \Cpp{}.

\begin{example}

\begin{codeblock}

void one(pair<int, int>); // \#1

void one(span<const int>); // \#2

void t1() { one({1, 2}); } // ambiguous between \#1 and \#2; previously called \#1

void two(span<const int, 2>);

void t2() { two({{1, 2}}); } // ill-formed; previously well-formed

void *a[10];

int x = span<void* const>{a, 0}.size(); // \tcode{x} is \tcode{2}; previously \tcode{0}

any b[10];

int y = span<const any>{b, b + 10}.size(); // \tcode{y} is \tcode{2}; previously \tcode{10}

\end{codeblock}

\end{example}

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

immediately followed by a \tcode{>} token

may be ill-formed or have different semantics in this revision of \Cpp{}.

\begin{example}

\begin{codeblock}

namespace N {

struct X {};

bool operator<=(X, X);

template<bool(X, X)> struct Y {};

Y<operator<=> y; // ill-formed; previously well-formed

}

\end{codeblock}

\end{example}

\diffref{lex.literal}

\indextext{UTF-8}%

Type of UTF-8 string and character literals.

Required for new features.

The changed types enable function overloading, template specialization, and

type deduction to distinguish ordinary and UTF-8 string and character literals.

Valid \CppXVII{} code that depends on

UTF-8 string literals having type ``array of \tcode{const char}'' and

UTF-8 character literals having type ``\tcode{char}''

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

\begin{example}

\begin{codeblock}

const auto *u8s = u8"text"; // \tcode{u8s} previously deduced as \tcode{const char*}; now deduced as \tcode{const char8_t*}

const char *ps = u8s; // ill-formed; previously well-formed

auto u8c = u8'c'; // \tcode{u8c} previously deduced as \tcode{char}; now deduced as \keyword{char8_t}

char *pc = &u8c; // ill-formed; previously well-formed

std::string s = u8"text"; // ill-formed; previously well-formed

void f(const char *s);

f(u8"text"); // ill-formed; previously well-formed

template<typename> struct ct;

template<> struct ct<char> {

using type = char;

};

ct<decltype(u8'c')>::type x; // ill-formed; previously well-formed.

\end{codeblock}

\end{example}

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

\diffref{basic.life}

A pseudo-destructor call ends the lifetime of

the object to which it is applied.

Increase consistency of the language model.

Valid ISO \CppXVII{} code may be ill-formed or

have undefined behavior in this revision of \Cpp{}.

\begin{example}

\begin{codeblock}

int f() {

int a = 123;

using T = int;

a.~T();

return a; // undefined behavior; previously returned 123

}

\end{codeblock}

\end{example}

\diffref{intro.races}

Except for the initial release operation,

a release sequence consists solely of atomic read-modify-write operations.

Removal of rarely used and confusing feature.