[diff.cpp20] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpxd80fxyc/{from.md → to.md} +76 -25

tmp/tmpxd80fxyc/{from.md → to.md} RENAMED Viewed

@@ -1,12 +1,12 @@
 ## C++ and ISO C++20 <a id="diff.cpp20">[[diff.cpp20]]</a>
 ### General <a id="diff.cpp20.general">[[diff.cpp20.general]]</a>
-Subclause [[diff.cpp20]] lists the differences between C++ and ISO C++20
-(ISO/IEC 14882:2020, *Programming Languages — C++*), by the chapters of
-this document.
 ###  [[lex]]: lexical conventions <a id="diff.cpp20.lex">[[diff.cpp20.lex]]</a>
 **Change:** Previously valid identifiers containing characters not
 present in UAX \#44 properties XID_Start or XID_Continue, or not in
@@ -17,47 +17,61 @@ identifiers are no longer well-formed.
 **Change:** Concatenated *string-literal*s can no longer have
 conflicting *encoding-prefix*es. **Rationale:** Removal of unimplemented
 conditionally-supported feature. **Effect on original feature:**
 Concatenation of *string-literal*s with different *encoding-prefix*es is
-now ill-formed. For example:
 ``` cpp
 auto c = L"a" U"b";             // was conditionally-supported; now ill-formed
 ```
 ###  [[expr]]: expressions <a id="diff.cpp20.expr">[[diff.cpp20.expr]]</a>
 **Change:** Change move-eligible *id-expression*s from lvalues to
 xvalues. **Rationale:** Simplify the rules for implicit move. **Effect
 on original feature:** Valid C++20 code that relies on a returned
 *id-expression*’s being an lvalue may change behavior or fail to
-compile. For example:
 ``` cpp
 decltype(auto) f(int&& x) { return (x); }       // returns int&&; previously returned int&
 int& g(int&& x) { return x; }                   // ill-formed; previously well-formed
 ```
 **Change:** Change the meaning of comma in subscript expressions.
 **Rationale:** Enable repurposing a deprecated syntax to support
 multidimensional indexing. **Effect on original feature:** Valid C++20
 code that uses a comma expression within a subscript expression may fail
-to compile. For example:
 ``` cpp
 arr[1, 2]               // was equivalent to arr[(1, 2)],
                         // now equivalent to arr.operator[](1, 2) or ill-formed
 ```
-###  [[stmt.stmt]]: statements <a id="diff.cpp20.stmt">[[diff.cpp20.stmt]]</a>
 **Change:** The lifetime of temporary objects in the
 *for-range-initializer* is extended until the end of the loop
 [[class.temporary]]. **Rationale:** Improve usability of the range-based
 `for` statement. **Effect on original feature:** Destructors of some
-temporary objects are invoked later. For example:
 ``` cpp
 void f() {
   std::vector<int> v = { 42, 17, 13 };
   std::mutex m;
@@ -67,19 +81,23 @@ void f() {
     std::lock_guard<std::mutex> guard(m);                       // OK in C++20, now deadlocks
   }
 }
 ```
-###  [[dcl.dcl]]: declarations <a id="diff.cpp20.dcl">[[diff.cpp20.dcl]]</a>
 **Change:** UTF-8 string literals may initialize arrays of `char` or
 `unsigned char`. **Rationale:** Compatibility with previously written
 code that conformed to previous versions of this document. **Effect on
 original feature:** Arrays of `char` or `unsigned 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. For example:
 ``` cpp
 struct A {
   char8_t s[10];
 };
@@ -93,43 +111,51 @@ void f(B);
 int main() {
   f({u8""});            // ambiguous
 }
 ```
 ###  [[temp]]: templates <a id="diff.cpp20.temp">[[diff.cpp20.temp]]</a>
 **Change:** Deducing template arguments from exception specifications.
 **Rationale:** Facilitate generic handling of throwing and non-throwing
 functions. **Effect on original feature:** Valid ISO C++20 code may be
-ill-formed in this revision of C++. For example:
 ``` cpp
 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
 }
 ```
 ###  [[library]]: library introduction <a id="diff.cpp20.library">[[diff.cpp20.library]]</a>
 **Change:** New headers. **Rationale:** New functionality. **Effect on
 original feature:** The following C++ headers are new: `<expected>`,
-`<flat_map>`, `<flat_set>`, `<generator>`, `<print>`, `<spanstream>`,
-`<stacktrace>`, and `<stdatomic.h>`. Valid C++20 code that `#include`s
-headers with these names may be invalid in this revision of C++.
 ###  [[concepts]]: concepts library <a id="diff.cpp20.concepts">[[diff.cpp20.concepts]]</a>
 **Change:** Replace `common_reference_with` in
 `three_way_comparable_with`, `equality_comparable_with`, and
 `totally_ordered_with` with an exposition-only concept. **Rationale:**
 Allow uncopyable, but movable, types to model these concepts. **Effect
 on original feature:** Valid C++20 code relying on subsumption with
-`common_reference_with` may fail to compile in this revision of C++. For
-example:
 ``` cpp
 template<class T, class U>
   requires equality_comparable_with<T, U>
 bool attempted_equals(const T&, const U& u);    // previously selected overload
@@ -141,10 +167,12 @@ bool attempted_equals(const T& t, const U& u);  // ambiguous overload; previousl
 bool test(shared_ptr<int> p) {
   return attempted_equals(p, nullptr);          // ill-formed; previously well-formed
 }
 ```
 ###  [[mem]]: memory management library <a id="diff.cpp20.memory">[[diff.cpp20.memory]]</a>
 **Change:** Forbid partial and explicit program-defined specializations
 of `allocator_traits`. **Rationale:** Allow addition of
 `allocate_at_least` to `allocator_traits`, and potentially other members
@@ -158,44 +186,56 @@ with no diagnostic required in this revision of C++.
 `format_to_n`, `formatted_size`. Removal of `format_args_t`.
 **Rationale:** Improve safety via compile-time format string checks,
 avoid unnecessary template instantiations. **Effect on original
 feature:** Valid C++20 code that contained errors in format strings or
 relied on previous format string signatures or `format_args_t` may
-become ill-formed. For example:
 ``` cpp
 auto s = std::format("{:d}", "I am not a number");      // ill-formed,
                                                         // previously threw format_error
 ```
 **Change:** Signature changes: `format`, `format_to`, `format_to_n`,
 `formatted_size`. **Rationale:** Enable formatting of views that do not
 support iteration when const-qualified and that are not copyable.
-**Effect on original feature:** Valid C++20 code that passes bit fields
-to formatting functions may become ill-formed. For example:
 ``` cpp
 struct tiny {
   int bit: 1;
 };
 auto t = tiny();
 std::format("{}", t.bit);       // ill-formed, previously returned "0"
 ```
 **Change:** Restrict types of formatting arguments used as *width* or
 *precision* in a *std-format-spec*. **Rationale:** Disallow types that
 do not have useful or portable semantics as a formatting width or
 precision. **Effect on original feature:** Valid C++20 code that passes
-a boolean or character type as *arg-id* becomes invalid. For example:
 ``` cpp
 std::format("{:*^{}}", "", true);   // ill-formed, previously returned "*"
 std::format("{:*^{}}", "", '1');    // ill-formed, previously returned an
                                     // implementation-defined number of '*' characters
 ```
 **Change:** Removed the `formatter` specialization:
 ``` cpp
 template<size_t N> struct formatter<const charT[N], charT>;
 ```
@@ -211,40 +251,47 @@ code that instantiated the removed specialization can become ill-formed.
 and the corresponding constructor. **Rationale:** Improve efficiency of
 operations on rvalues. **Effect on original feature:** Valid C++20 code
 that created a substring by calling `substr` (or the corresponding
 constructor) on an xvalue expression with type `S` that is a
 specialization of `basic_string` may change meaning in this revision of
-C++. For example:
 ``` cpp
 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 true
 std::string s3(std::move(s2), 10, 5);
 assert(s1 == s2);       // unspecified, previously guaranteed to be true
 ```
 ###  [[containers]]: containers library <a id="diff.cpp20.containers">[[diff.cpp20.containers]]</a>
 **Change:** Heterogeneous `extract` and `erase` overloads for
 associative containers. **Rationale:** Improve efficiency of erasing
 elements from associative containers. **Effect on original feature:**
-Valid C++20 code may fail to compile in this revision of C++. For
-example:
 ``` cpp
 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
   }
 };
 ```
 ###  [[thread]]: concurrency support library <a id="diff.cpp20.thread">[[diff.cpp20.thread]]</a>
 **Change:** In this revision of C++, it is implementation-defined
 whether a barrier’s phase completion step runs if no thread calls
 `wait`. Previously the phase completion step was guaranteed to run on
@@ -255,11 +302,13 @@ Correct contradictory wording and improve implementation flexibility for
 performance. **Effect on original feature:** Valid C++20 code using a
 barrier might have different semantics in this revision of C++ 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 `wait` having been
-called. For example:
 ``` cpp
 auto b0 = std::barrier(1);
 b0.arrive();
 b0.arrive();            // implementation-defined; previously well-defined
@@ -269,5 +318,7 @@ auto b1 = std::barrier(1, [&] { data++; });
 b1.arrive();
 assert(data == 1);      // implementation-defined; previously well-defined
 b1.arrive();            // implementation-defined; previously well-defined
 ```

 ## C++ and ISO C++20 <a id="diff.cpp20">[[diff.cpp20]]</a>
 ### General <a id="diff.cpp20.general">[[diff.cpp20.general]]</a>
+Subclause [[diff.cpp20]] lists the differences between C++ and ISO
+C++20, in addition to those listed above, by the chapters of this
+document.
 ###  [[lex]]: lexical conventions <a id="diff.cpp20.lex">[[diff.cpp20.lex]]</a>
 **Change:** Previously valid identifiers containing characters not
 present in UAX \#44 properties XID_Start or XID_Continue, or not in
 **Change:** Concatenated *string-literal*s can no longer have
 conflicting *encoding-prefix*es. **Rationale:** Removal of unimplemented
 conditionally-supported feature. **Effect on original feature:**
 Concatenation of *string-literal*s with different *encoding-prefix*es is
+now ill-formed.
+[*Example 1*:
 ``` cpp
 auto c = L"a" U"b";             // was conditionally-supported; now ill-formed
 ```
+— *end example*]
 ###  [[expr]]: expressions <a id="diff.cpp20.expr">[[diff.cpp20.expr]]</a>
 **Change:** Change move-eligible *id-expression*s from lvalues to
 xvalues. **Rationale:** Simplify the rules for implicit move. **Effect
 on original feature:** Valid C++20 code that relies on a returned
 *id-expression*’s being an lvalue may change behavior or fail to
+compile.
+[*Example 1*:
 ``` cpp
 decltype(auto) f(int&& x) { return (x); }       // returns int&&; previously returned int&
 int& g(int&& x) { return x; }                   // ill-formed; previously well-formed
 ```
+— *end example*]
 **Change:** Change the meaning of comma in subscript expressions.
 **Rationale:** Enable repurposing a deprecated syntax to support
 multidimensional indexing. **Effect on original feature:** Valid C++20
 code that uses a comma expression within a subscript expression may fail
+to compile.
+[*Example 2*:
 ``` cpp
 arr[1, 2]               // was equivalent to arr[(1, 2)],
                         // now equivalent to arr.operator[](1, 2) or ill-formed
 ```
+— *end example*]
+###  [[stmt]]: statements <a id="diff.cpp20.stmt">[[diff.cpp20.stmt]]</a>
 **Change:** The lifetime of temporary objects in the
 *for-range-initializer* is extended until the end of the loop
 [[class.temporary]]. **Rationale:** Improve usability of the range-based
 `for` statement. **Effect on original feature:** Destructors of some
+temporary objects are invoked later.
+[*Example 1*:
 ``` cpp
 void f() {
   std::vector<int> v = { 42, 17, 13 };
   std::mutex m;
     std::lock_guard<std::mutex> guard(m);                       // OK in C++20, now deadlocks
   }
 }
 ```
+— *end example*]
+###  [[dcl]]: declarations <a id="diff.cpp20.dcl">[[diff.cpp20.dcl]]</a>
 **Change:** UTF-8 string literals may initialize arrays of `char` or
 `unsigned char`. **Rationale:** Compatibility with previously written
 code that conformed to previous versions of this document. **Effect on
 original feature:** Arrays of `char` or `unsigned 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.
+[*Example 1*:
 ``` cpp
 struct A {
   char8_t s[10];
 };
 int main() {
   f({u8""});            // ambiguous
 }
 ```
+— *end example*]
 ###  [[temp]]: templates <a id="diff.cpp20.temp">[[diff.cpp20.temp]]</a>
 **Change:** Deducing template arguments from exception specifications.
 **Rationale:** Facilitate generic handling of throwing and non-throwing
 functions. **Effect on original feature:** Valid ISO C++20 code may be
+ill-formed in this revision of C++.
+[*Example 1*:
 ``` cpp
 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 example*]
 ###  [[library]]: library introduction <a id="diff.cpp20.library">[[diff.cpp20.library]]</a>
 **Change:** New headers. **Rationale:** New functionality. **Effect on
 original feature:** The following C++ headers are new: `<expected>`,
+`<flat_map>`, `<flat_set>`, `<generator>`, `<mdspan>`, `<print>`,
+`<spanstream>`, `<stacktrace>`, `<stdatomic.h>`, and `<stdfloat>`. Valid
+C++20 code that `#include`s headers with these names may be invalid in
+this revision of C++.
 ###  [[concepts]]: concepts library <a id="diff.cpp20.concepts">[[diff.cpp20.concepts]]</a>
 **Change:** Replace `common_reference_with` in
 `three_way_comparable_with`, `equality_comparable_with`, and
 `totally_ordered_with` with an exposition-only concept. **Rationale:**
 Allow uncopyable, but movable, types to model these concepts. **Effect
 on original feature:** Valid C++20 code relying on subsumption with
+`common_reference_with` may fail to compile in this revision of C++.
+[*Example 1*:
 ``` cpp
 template<class T, class U>
   requires equality_comparable_with<T, U>
 bool attempted_equals(const T&, const U& u);    // previously selected overload
 bool test(shared_ptr<int> p) {
   return attempted_equals(p, nullptr);          // ill-formed; previously well-formed
 }
 ```
+— *end example*]
 ###  [[mem]]: memory management library <a id="diff.cpp20.memory">[[diff.cpp20.memory]]</a>
 **Change:** Forbid partial and explicit program-defined specializations
 of `allocator_traits`. **Rationale:** Allow addition of
 `allocate_at_least` to `allocator_traits`, and potentially other members
 `format_to_n`, `formatted_size`. Removal of `format_args_t`.
 **Rationale:** Improve safety via compile-time format string checks,
 avoid unnecessary template instantiations. **Effect on original
 feature:** Valid C++20 code that contained errors in format strings or
 relied on previous format string signatures or `format_args_t` may
+become ill-formed.
+[*Example 1*:
 ``` cpp
 auto s = std::format("{:d}", "I am not a number");      // ill-formed,
                                                         // previously threw format_error
 ```
+— *end example*]
 **Change:** Signature changes: `format`, `format_to`, `format_to_n`,
 `formatted_size`. **Rationale:** Enable formatting of views that do not
 support iteration when const-qualified and that are not copyable.
+**Effect on original feature:** Valid C++20 code that passes bit-fields
+to formatting functions may become ill-formed.
+[*Example 2*:
 ``` cpp
 struct tiny {
   int bit: 1;
 };
 auto t = tiny();
 std::format("{}", t.bit);       // ill-formed, previously returned "0"
 ```
+— *end example*]
 **Change:** Restrict types of formatting arguments used as *width* or
 *precision* in a *std-format-spec*. **Rationale:** Disallow types that
 do not have useful or portable semantics as a formatting width or
 precision. **Effect on original feature:** Valid C++20 code that passes
+a boolean or character type as *arg-id* becomes invalid.
+[*Example 3*:
 ``` cpp
 std::format("{:*^{}}", "", true);   // ill-formed, previously returned "*"
 std::format("{:*^{}}", "", '1');    // ill-formed, previously returned an
                                     // implementation-defined number of '*' characters
 ```
+— *end example*]
 **Change:** Removed the `formatter` specialization:
 ``` cpp
 template<size_t N> struct formatter<const charT[N], charT>;
 ```
 and the corresponding constructor. **Rationale:** Improve efficiency of
 operations on rvalues. **Effect on original feature:** Valid C++20 code
 that created a substring by calling `substr` (or the corresponding
 constructor) on an xvalue expression with type `S` that is a
 specialization of `basic_string` may change meaning in this revision of
+C++.
+[*Example 1*:
 ``` cpp
 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 true
 std::string s3(std::move(s2), 10, 5);
 assert(s1 == s2);       // unspecified, previously guaranteed to be true
 ```
+— *end example*]
 ###  [[containers]]: containers library <a id="diff.cpp20.containers">[[diff.cpp20.containers]]</a>
 **Change:** Heterogeneous `extract` and `erase` overloads for
 associative containers. **Rationale:** Improve efficiency of erasing
 elements from associative containers. **Effect on original feature:**
+Valid C++20 code may fail to compile in this revision of C++.
+[*Example 1*:
 ``` cpp
 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 example*]
 ###  [[thread]]: concurrency support library <a id="diff.cpp20.thread">[[diff.cpp20.thread]]</a>
 **Change:** In this revision of C++, it is implementation-defined
 whether a barrier’s phase completion step runs if no thread calls
 `wait`. Previously the phase completion step was guaranteed to run on
 performance. **Effect on original feature:** Valid C++20 code using a
 barrier might have different semantics in this revision of C++ 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 `wait` having been
+called.
+[*Example 1*:
 ``` cpp
 auto b0 = std::barrier(1);
 b0.arrive();
 b0.arrive();            // implementation-defined; previously well-defined
 b1.arrive();
 assert(data == 1);      // implementation-defined; previously well-defined
 b1.arrive();            // implementation-defined; previously well-defined
 ```
+— *end example*]

Diff to HTML by rtfpessoa