[diff.cpp17] - C++20 → C++23

Files changed (1) hide show

tmp/tmp02p5b3_3/{from.md → to.md} +82 -62

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

@@ -1,47 +1,41 @@
 ## C++ and ISO C++17 <a id="diff.cpp17">[[diff.cpp17]]</a>
-This subclause lists the differences between C++ and ISO C++17 (ISO/IEC
-14882:2017, *Programming Languages — C++*), by the chapters of this
-document.
 ###  [[lex]]: lexical conventions <a id="diff.cpp17.lex">[[diff.cpp17.lex]]</a>
 **Change:** New identifiers with special meaning. **Rationale:**
 Required for new features. **Effect on original feature:** Logical lines
 beginning with `module` or `import` may be interpreted differently in
-this International Standard.
-[*Example 1*:
 ``` cpp
 class module {};
 module m1;          // was variable declaration; now module-declaration
 module *m2;         // variable declaration
 class import {};
-import j1;          // was variable declaration; now import-declaration
 ::import j2;        // variable declaration
 ```
-— *end example*]
 **Change:** *header-name* tokens are formed in more contexts.
 **Rationale:** Required for new features. **Effect on original
 feature:** When the identifier `import` is followed by a `<` character,
-a *header-name* token may be formed.
-[*Example 2*:
 ``` cpp
 template<typename> class import {};
 import<int> f();                // ill-formed; previously well-formed
 ::import<int> g();              // OK
 ```
-— *end example*]
 **Change:** New keywords. **Rationale:** Required for new features.
 - The `char8_t` keyword is added to differentiate the types of ordinary
   and UTF-8 literals [[lex.string]].
 - The `concept` keyword is added to enable the definition of concepts
@@ -56,16 +50,17 @@ import<int> f();                // ill-formed; previously well-formed
   *requires-clause* [[temp.pre]] or a *requires-expression*
   [[expr.prim.req]].
 Valid C++17 code using `char8_t`, `concept`, `consteval`, `constinit`,
 `co_await`, `co_yield`, `co_return`, or `requires` as an identifier is
-not valid in this International Standard.
 **Change:** New operator `<=>`. **Rationale:** Necessary for new
 functionality. **Effect on original feature:** Valid C++17 code that
 contains a `<=` token immediately followed by a `>` token may be
-ill-formed or have different semantics in this International Standard:
 ``` cpp
 namespace N {
   struct X {};
   bool operator<=(X, X);
@@ -78,11 +73,11 @@ namespace N {
 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. **Effect on original
 feature:** Valid C++17 code that depends on UTF-8 string literals having
 type “array of `const char`” and UTF-8 character literals having type
-“`char`” is not valid in this International Standard.
 ``` cpp
 const auto *u8s = u8"text";     // u8s previously deduced as const char*; now deduced as const char8_t*
 const char *ps = u8s;           // ill-formed; previously well-formed
@@ -104,25 +99,22 @@ ct<decltype(u8'c')>::type x;    // ill-formed; previously well-formed.
 ###  [[basic]]: basics <a id="diff.cpp17.basic">[[diff.cpp17.basic]]</a>
 **Change:** A pseudo-destructor call ends the lifetime of the object to
 which it is applied. **Rationale:** Increase consistency of the language
 model. **Effect on original feature:** Valid ISO C++17 code may be
-ill-formed or have undefined behavior in this International Standard.
-[*Example 1*:
 ``` cpp
 int f() {
   int a = 123;
   using T = int;
   a.~T();
   return a;         // undefined behavior; previously returned 123
 }
 ```
-— *end example*]
 **Change:** Except for the initial release operation, a release sequence
 consists solely of atomic read-modify-write operations. **Rationale:**
 Removal of rarely used and confusing feature. **Effect on original
 feature:** If a `memory_order_release` atomic store is followed by a
 `memory_order_relaxed` store to the same variable by the same thread,
@@ -142,22 +134,23 @@ result in an odr-use.
 ###  [[dcl.dcl]]: declarations <a id="diff.cpp17.dcl.dcl">[[diff.cpp17.dcl.dcl]]</a>
 **Change:** Unnamed classes with a typedef name for linkage purposes can
 contain only C-compatible constructs. **Rationale:** Necessary for
 implementability. **Effect on original feature:** Valid C++17 code may
-be ill-formed in this International Standard.
 ``` cpp
 typedef struct {
   void f() {}           // ill-formed; previously well-formed
 } S;
 ```
 **Change:** A function cannot have different default arguments in
 different translation units. **Rationale:** Required for modules
 support. **Effect on original feature:** Valid C++17 code may be
-ill-formed in this International Standard, with no diagnostic required.
 ``` cpp
 // Translation unit 1
 int f(int a = 42);
 int g() { return f(); }
@@ -171,11 +164,12 @@ int main() { return g(); }              // used to return 42
 **Change:** A class that has user-declared constructors is never an
 aggregate. **Rationale:** Remove potentially error-prone aggregate
 initialization which may apply notwithstanding the declared constructors
 of a class. **Effect on original feature:** Valid C++17 code that
 aggregate-initializes a type with a user-declared constructor may be
-ill-formed or have different semantics in this International Standard.
 ``` cpp
 struct A {              // not an aggregate; previously an aggregate
   A() = delete;
 };
@@ -209,11 +203,11 @@ Y y{X{}};               // copy constructor call; previously aggregate-initializ
 ```
 **Change:** Boolean conversion from a pointer or pointer-to-member type
 is now a narrowing conversion. **Rationale:** Catches bugs. **Effect on
 original feature:** Valid C++17 code may fail to compile in this
-International Standard. For example:
 ``` cpp
 bool y[] = { "bc" };    // ill-formed; previously well-formed
 ```
@@ -223,11 +217,11 @@ bool y[] = { "bc" };    // ill-formed; previously well-formed
 immediately after an `explicit` *decl-specifier* in a constructor
 declaration. The *conversion-function-id* can no longer be used
 parenthesized immediately after an `explicit` *decl-specifier* in a
 conversion function declaration. **Rationale:** Necessary for new
 functionality. **Effect on original feature:** Valid C++17 code may fail
-to compile in this International Standard. For example:
 ``` cpp
 struct S {
   explicit (S)(const S&);       // ill-formed; previously well-formed
   explicit (operator int)();    // ill-formed; previously well-formed
@@ -236,12 +230,12 @@ struct S {
 ```
 **Change:** A *simple-template-id* is no longer valid as the
 *declarator-id* of a constructor or destructor. **Rationale:** Remove
 potentially error-prone option for redundancy. **Effect on original
-feature:** Valid C++17 code may fail to compile in this International
-Standard. For example:
 ``` cpp
 template<class T>
 struct A {
   A<T>();           // error: simple-template-id not allowed for constructor
@@ -254,11 +248,11 @@ struct A {
 a constructor taking an rvalue reference to a type different from that
 of the returned expression. Function and catch-clause parameters can be
 thrown using move constructors. **Rationale:** Side effect of making it
 easier to write more efficient code that takes advantage of moves.
 **Effect on original feature:** Valid C++17 code may fail to compile or
-have different semantics in this International Standard. For example:
 ``` cpp
 struct base {
   base();
   base(base const &);
@@ -293,15 +287,16 @@ void g() {
 ###  [[over]]: overloading <a id="diff.cpp17.over">[[diff.cpp17.over]]</a>
 **Change:** Equality and inequality expressions can now find reversed
 and rewritten candidates. **Rationale:** Improve consistency of equality
 with three-way comparison and make it easier to write the full
-complement of equality operations. **Effect on original feature:**
-Equality and inequality expressions between two objects of different
-types, where one is convertible to the other, could invoke a different
-operator. Equality and inequality expressions between two objects of the
-same type could become ambiguous.
 ``` cpp
 struct A {
   operator int() const;
 };
@@ -315,58 +310,80 @@ int check(A x, A y) {
     (10 == x) +                 // calls #1, previously selected #2
     (10 != x);                  // calls #1, previously selected #3
 }
 ```
 ###  [[temp]]: templates <a id="diff.cpp17.temp">[[diff.cpp17.temp]]</a>
 **Change:** An *unqualified-id* that is followed by a `<` and for which
 name lookup finds nothing or finds a function will be treated as a
 *template-name* in order to potentially cause argument dependent lookup
 to be performed. **Rationale:** It was problematic to call a function
 template with an explicit template argument list via argument dependent
 lookup because of the need to have a template with the same name visible
 via normal lookup. **Effect on original feature:** Previously valid code
 that uses a function name as the left operand of a `<` operator would
-become ill-formed.
 ``` cpp
 struct A {};
 bool operator<(void (*fp)(), A);
 void f() {}
 int main() {
   A a;
   f < a;    // ill-formed; previously well-formed
-  (f) < a;  // still well formed
 }
 ```
 ###  [[except]]: exception handling <a id="diff.cpp17.except">[[diff.cpp17.except]]</a>
 **Change:** Remove `throw()` exception specification. **Rationale:**
 Removal of obsolete feature that has been replaced by `noexcept`.
 **Effect on original feature:** A valid C++17 function declaration,
 member function declaration, function pointer declaration, or function
 reference declaration that uses `throw()` for its exception
-specification will be rejected as ill-formed in this International
-Standard. It should simply be replaced with `noexcept` for no change of
-meaning since C++17.
 [*Note 1*: There is no way to write a function declaration that is
-non-throwing in this International Standard and is also non-throwing in
-C++03 except by using the preprocessor to generate a different token
-sequence in each case. — *end note*]
 ###  [[library]]: library introduction <a id="diff.cpp17.library">[[diff.cpp17.library]]</a>
 **Change:** New headers. **Rationale:** New functionality. **Effect on
 original feature:** The following C++ headers are new: `<barrier>`,
 `<bit>`, `<charconv>`, `<compare>`, `<concepts>`, `<coroutine>`,
 `<format>`, `<latch>`, `<numbers>`, `<ranges>`, `<semaphore>`,
 `<source_location>`, `<span>`, `<stop_token>`, `<syncstream>`, and
 `<version>`. Valid C++17 code that `#include`s headers with these names
-may be invalid in this International Standard.
 **Change:** Remove vacuous C++ header files. **Rationale:** The empty
 headers implied a false requirement to achieve C compatibility with the
 C++ headers. **Effect on original feature:** A valid C++17 program that
 `#include`s any of the following headers may fail to compile:
@@ -384,14 +401,14 @@ To retain the same behavior:
 **Change:** Return types of `remove`, `remove_if`, and `unique` changed
 from `void` to `container::size_type`. **Rationale:** Improve efficiency
 and convenience of finding number of removed elements. **Effect on
 original feature:** Code that depends on the return types might have
-different semantics in this International Standard. Translation units
-compiled against this version of C++ may be incompatible with
-translation units compiled against C++17, either failing to link or
-having undefined behavior.
 ###  [[iterators]]: iterators library <a id="diff.cpp17.iterators">[[diff.cpp17.iterators]]</a>
 **Change:** The specialization of `iterator_traits` for `void*` and for
 function pointer types no longer contains any nested typedefs.
@@ -414,11 +431,11 @@ have undefined behavior.
 ###  [[input.output]]: input/output library <a id="diff.cpp17.input.output">[[diff.cpp17.input.output]]</a>
 **Change:** Character array extraction only takes array types.
 **Rationale:** Increase safety via preventing buffer overflow at compile
 time. **Effect on original feature:** Valid C++17 code may fail to
-compile in this International Standard:
 ``` cpp
 auto p = new char[100];
 char q[100];
 std::cin >> std::setw(20) >> p;         // ill-formed; previously well-formed
@@ -427,11 +444,12 @@ std::cin >> std::setw(20) >> q;         // OK
 **Change:** Overload resolution for ostream inserters used with UTF-8
 literals. **Rationale:** Required for new features. **Effect on original
 feature:** Valid C++17 code that passes UTF-8 literals to
 `basic_ostream<char, ...>::operator<<` or
-`basic_ostream<wchar_t, ...>::operator<<` is now ill-formed.
 ``` cpp
 std::cout << u8"text";          // previously called operator<<(const char*) and printed a string;
                                 // now ill-formed
 std::cout << u8'X';             // previously called operator<<(char) and printed a character;
@@ -442,11 +460,12 @@ std::cout << u8'X';             // previously called operator<<(char) and printe
 `wchar_t`, `char16_t`, or `char32_t` types. **Rationale:** Removal of
 surprising behavior. **Effect on original feature:** Valid C++17 code
 that passes `wchar_t`, `char16_t`, or `char32_t` characters or strings
 to `basic_ostream<char, ...>::operator<<` or that passes `char16_t` or
 `char32_t` characters or strings to
-`basic_ostream<wchar_t, ...>::operator<<` is now ill-formed.
 ``` cpp
 std::cout << u"text";           // previously formatted the string as a pointer value;
                                 // now ill-formed
 std::cout << u'X';              // previously formatted the character as an integer value;
@@ -455,11 +474,12 @@ std::cout << u'X';              // previously formatted the character as an inte
 **Change:** Return type of filesystem path format observer member
 functions. **Rationale:** Required for new features. **Effect on
 original feature:** Valid C++17 code that depends on the `u8string()`
 and `generic_u8string()` member functions of `std::filesystem::path`
-returning `std::string` is not valid in this International Standard.
 ``` cpp
 std::filesystem::path p;
 std::string s1 = p.u8string();          // ill-formed; previously well-formed
 std::string s2 = p.generic_u8string();  // ill-formed; previously well-formed
@@ -469,12 +489,12 @@ std::string s2 = p.generic_u8string();  // ill-formed; previously well-formed
 **Change:** Remove `uncaught_exception`. **Rationale:** The function did
 not have a clear specification when multiple exceptions were active, and
 has been superseded by `uncaught_exceptions`. **Effect on original
 feature:** A valid C++17 program that calls `std::uncaught_exception`
-may fail to compile. It might be revised to use
-`std::uncaught_exceptions` instead, for clear and portable semantics.
 **Change:** Remove support for adaptable function API. **Rationale:**
 The deprecated support relied on a limited convention that could not be
 extended to support the general case or new language features. It has
 been superseded by direct language support with `decltype`, and by the
@@ -493,14 +513,14 @@ C++17 program that directly makes use of the `pointer`, `const_pointer`,
 `reference`, `const_reference`, `rebind`, `address`, `construct`,
 `destroy`, or `max_size` members of `std::allocator`, or that directly
 calls `allocate` with an additional hint argument, may fail to compile.
 **Change:** Remove `raw_storage_iterator`. **Rationale:** The iterator
-encouraged use of algorithms that might throw exceptions, but did not
-return the number of elements successfully constructed that might need
-to be destroyed in order to avoid leaks. **Effect on original feature:**
-A valid C++17 program that uses this iterator class may fail to compile.
 **Change:** Remove temporary buffers API. **Rationale:** The temporary
 buffer facility was intended to provide an efficient optimization for
 small memory requests, but there is little evidence this was achieved in
 practice, while requiring the user to provide their own exception-safe
@@ -510,19 +530,19 @@ original feature:** A valid C++17 program that calls
 **Change:** Remove `shared_ptr::unique`. **Rationale:** The result of a
 call to this member function is not reliable in the presence of multiple
 threads and weak pointers. The member function `use_count` is similarly
 unreliable, but has a clearer contract in such cases, and remains
-available for well defined use in single-threaded cases. **Effect on
 original feature:** A valid C++17 program that calls `unique` on a
 `shared_ptr` object may fail to compile.
 **Change:** Remove deprecated type traits. **Rationale:** The traits had
 unreliable or awkward interfaces. The `is_literal_type` trait provided
 no way to detect which subset of constructors and member functions of a
 type were declared `constexpr`. The `result_of` trait had a surprising
-syntax that could not report the result of a regular function type. It
-has been superseded by the `invoke_result` trait. **Effect on original
-feature:** A valid C++17 program that relies on the `is_literal_type` or
 `result_of` type traits, on the `is_literal_type_v` variable template,
 or on the `result_of_t` alias template may fail to compile.

 ## C++ and ISO C++17 <a id="diff.cpp17">[[diff.cpp17]]</a>
+### General <a id="diff.cpp17.general">[[diff.cpp17.general]]</a>
+Subclause [[diff.cpp17]] lists the differences between C++ and ISO C++17
+(ISO/IEC 14882:2017, *Programming Languages — C++*), by the chapters of
+this document.
 ###  [[lex]]: lexical conventions <a id="diff.cpp17.lex">[[diff.cpp17.lex]]</a>
 **Change:** New identifiers with special meaning. **Rationale:**
 Required for new features. **Effect on original feature:** Logical lines
 beginning with `module` or `import` may be interpreted differently in
+this revision of C++. For example:
 ``` cpp
 class module {};
 module m1;          // was variable declaration; now module-declaration
 module *m2;         // variable declaration
 class import {};
+import j1;          // was variable declaration; now module-import-declaration
 ::import j2;        // variable declaration
 ```
 **Change:** *header-name* tokens are formed in more contexts.
 **Rationale:** Required for new features. **Effect on original
 feature:** When the identifier `import` is followed by a `<` character,
+a *header-name* token may be formed. For example:
 ``` cpp
 template<typename> class import {};
 import<int> f();                // ill-formed; previously well-formed
 ::import<int> g();              // OK
 ```
 **Change:** New keywords. **Rationale:** Required for new features.
 - The `char8_t` keyword is added to differentiate the types of ordinary
   and UTF-8 literals [[lex.string]].
 - The `concept` keyword is added to enable the definition of concepts
   *requires-clause* [[temp.pre]] or a *requires-expression*
   [[expr.prim.req]].
 Valid C++17 code using `char8_t`, `concept`, `consteval`, `constinit`,
 `co_await`, `co_yield`, `co_return`, or `requires` as an identifier is
+not valid in this revision of C++.
 **Change:** New operator `<=>`. **Rationale:** Necessary for new
 functionality. **Effect on original feature:** Valid C++17 code that
 contains a `<=` token immediately followed by a `>` token may be
+ill-formed or have different semantics in this revision of C++. For
+example:
 ``` cpp
 namespace N {
   struct X {};
   bool operator<=(X, X);
 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. **Effect on original
 feature:** Valid C++17 code that depends on UTF-8 string literals having
 type “array of `const char`” and UTF-8 character literals having type
+“`char`” is not valid in this revision of C++. For example:
 ``` cpp
 const auto *u8s = u8"text";     // u8s previously deduced as const char*; now deduced as const char8_t*
 const char *ps = u8s;           // ill-formed; previously well-formed
 ###  [[basic]]: basics <a id="diff.cpp17.basic">[[diff.cpp17.basic]]</a>
 **Change:** A pseudo-destructor call ends the lifetime of the object to
 which it is applied. **Rationale:** Increase consistency of the language
 model. **Effect on original feature:** Valid ISO C++17 code may be
+ill-formed or have undefined behavior in this revision of C++. For
+example:
 ``` cpp
 int f() {
   int a = 123;
   using T = int;
   a.~T();
   return a;         // undefined behavior; previously returned 123
 }
 ```
 **Change:** Except for the initial release operation, a release sequence
 consists solely of atomic read-modify-write operations. **Rationale:**
 Removal of rarely used and confusing feature. **Effect on original
 feature:** If a `memory_order_release` atomic store is followed by a
 `memory_order_relaxed` store to the same variable by the same thread,
 ###  [[dcl.dcl]]: declarations <a id="diff.cpp17.dcl.dcl">[[diff.cpp17.dcl.dcl]]</a>
 **Change:** Unnamed classes with a typedef name for linkage purposes can
 contain only C-compatible constructs. **Rationale:** Necessary for
 implementability. **Effect on original feature:** Valid C++17 code may
+be ill-formed in this revision of C++. For example:
 ``` cpp
 typedef struct {
   void f() {}           // ill-formed; previously well-formed
 } S;
 ```
 **Change:** A function cannot have different default arguments in
 different translation units. **Rationale:** Required for modules
 support. **Effect on original feature:** Valid C++17 code may be
+ill-formed in this revision of C++, with no diagnostic required. For
+example:
 ``` cpp
 // Translation unit 1
 int f(int a = 42);
 int g() { return f(); }
 **Change:** A class that has user-declared constructors is never an
 aggregate. **Rationale:** Remove potentially error-prone aggregate
 initialization which may apply notwithstanding the declared constructors
 of a class. **Effect on original feature:** Valid C++17 code that
 aggregate-initializes a type with a user-declared constructor may be
+ill-formed or have different semantics in this revision of C++. For
+example:
 ``` cpp
 struct A {              // not an aggregate; previously an aggregate
   A() = delete;
 };
 ```
 **Change:** Boolean conversion from a pointer or pointer-to-member type
 is now a narrowing conversion. **Rationale:** Catches bugs. **Effect on
 original feature:** Valid C++17 code may fail to compile in this
+revision of C++. For example:
 ``` cpp
 bool y[] = { "bc" };    // ill-formed; previously well-formed
 ```
 immediately after an `explicit` *decl-specifier* in a constructor
 declaration. The *conversion-function-id* can no longer be used
 parenthesized immediately after an `explicit` *decl-specifier* in a
 conversion function declaration. **Rationale:** Necessary for new
 functionality. **Effect on original feature:** Valid C++17 code may fail
+to compile in this revision of C++. For example:
 ``` cpp
 struct S {
   explicit (S)(const S&);       // ill-formed; previously well-formed
   explicit (operator int)();    // ill-formed; previously well-formed
 ```
 **Change:** A *simple-template-id* is no longer valid as the
 *declarator-id* of a constructor or destructor. **Rationale:** Remove
 potentially error-prone option for redundancy. **Effect on original
+feature:** Valid C++17 code may fail to compile in this revision of C++.
+For example:
 ``` cpp
 template<class T>
 struct A {
   A<T>();           // error: simple-template-id not allowed for constructor
 a constructor taking an rvalue reference to a type different from that
 of the returned expression. Function and catch-clause parameters can be
 thrown using move constructors. **Rationale:** Side effect of making it
 easier to write more efficient code that takes advantage of moves.
 **Effect on original feature:** Valid C++17 code may fail to compile or
+have different semantics in this revision of C++. For example:
 ``` cpp
 struct base {
   base();
   base(base const &);
 ###  [[over]]: overloading <a id="diff.cpp17.over">[[diff.cpp17.over]]</a>
 **Change:** Equality and inequality expressions can now find reversed
 and rewritten candidates. **Rationale:** Improve consistency of equality
 with three-way comparison and make it easier to write the full
+complement of equality operations. **Effect on original feature:** For
+certain pairs of types where one is convertible to the other, equality
+or inequality expressions between an object of one type and an object of
+the other type invoke a different operator. Also, for certain types,
+equality or inequality expressions between two objects of that type
+become ambiguous. For example:
 ``` cpp
 struct A {
   operator int() const;
 };
     (10 == x) +                 // calls #1, previously selected #2
     (10 != x);                  // calls #1, previously selected #3
 }
 ```
+**Change:** Overload resolution may change for equality operators
+[[expr.eq]]. **Rationale:** Support calling `operator==` with reversed
+order of arguments. **Effect on original feature:** Valid C++17 code
+that uses equality operators with conversion functions may be ill-formed
+or have different semantics in this revision of C++. For example:
+``` cpp
+struct A {
+  operator int() const { return 10; }
+};
+bool operator==(A, int);        // #1
+// #2 is built-in candidate: bool operator==(int, int);
+bool b = 10 == A();             // calls #1 with reversed order of arguments; previously selected #2
+struct B {
+  bool operator==(const B&);    // member function with no cv-qualifier
+};
+B b1;
+bool eq = (b1 == b1);           // ambiguous; previously well-formed
+```
 ###  [[temp]]: templates <a id="diff.cpp17.temp">[[diff.cpp17.temp]]</a>
 **Change:** An *unqualified-id* that is followed by a `<` and for which
 name lookup finds nothing or finds a function will be treated as a
 *template-name* in order to potentially cause argument dependent lookup
 to be performed. **Rationale:** It was problematic to call a function
 template with an explicit template argument list via argument dependent
 lookup because of the need to have a template with the same name visible
 via normal lookup. **Effect on original feature:** Previously valid code
 that uses a function name as the left operand of a `<` operator would
+become ill-formed. For example:
 ``` cpp
 struct A {};
 bool operator<(void (*fp)(), A);
 void f() {}
 int main() {
   A a;
   f < a;    // ill-formed; previously well-formed
+  (f) < a;  // still well-formed
 }
 ```
 ###  [[except]]: exception handling <a id="diff.cpp17.except">[[diff.cpp17.except]]</a>
 **Change:** Remove `throw()` exception specification. **Rationale:**
 Removal of obsolete feature that has been replaced by `noexcept`.
 **Effect on original feature:** A valid C++17 function declaration,
 member function declaration, function pointer declaration, or function
 reference declaration that uses `throw()` for its exception
+specification will be rejected as ill-formed in this revision of C++. It
+should simply be replaced with `noexcept` for no change of meaning since
+C++17.
 [*Note 1*: There is no way to write a function declaration that is
+non-throwing in this revision of C++ and is also non-throwing in C++03
+except by using the preprocessor to generate a different token sequence
+in each case. — *end note*]
 ###  [[library]]: library introduction <a id="diff.cpp17.library">[[diff.cpp17.library]]</a>
 **Change:** New headers. **Rationale:** New functionality. **Effect on
 original feature:** The following C++ headers are new: `<barrier>`,
 `<bit>`, `<charconv>`, `<compare>`, `<concepts>`, `<coroutine>`,
 `<format>`, `<latch>`, `<numbers>`, `<ranges>`, `<semaphore>`,
 `<source_location>`, `<span>`, `<stop_token>`, `<syncstream>`, and
 `<version>`. Valid C++17 code that `#include`s headers with these names
+may be invalid in this revision of C++.
 **Change:** Remove vacuous C++ header files. **Rationale:** The empty
 headers implied a false requirement to achieve C compatibility with the
 C++ headers. **Effect on original feature:** A valid C++17 program that
 `#include`s any of the following headers may fail to compile:
 **Change:** Return types of `remove`, `remove_if`, and `unique` changed
 from `void` to `container::size_type`. **Rationale:** Improve efficiency
 and convenience of finding number of removed elements. **Effect on
 original feature:** Code that depends on the return types might have
+different semantics in this revision of C++. Translation units compiled
+against this version of C++ may be incompatible with translation units
+compiled against C++17, either failing to link or having undefined
+behavior.
 ###  [[iterators]]: iterators library <a id="diff.cpp17.iterators">[[diff.cpp17.iterators]]</a>
 **Change:** The specialization of `iterator_traits` for `void*` and for
 function pointer types no longer contains any nested typedefs.
 ###  [[input.output]]: input/output library <a id="diff.cpp17.input.output">[[diff.cpp17.input.output]]</a>
 **Change:** Character array extraction only takes array types.
 **Rationale:** Increase safety via preventing buffer overflow at compile
 time. **Effect on original feature:** Valid C++17 code may fail to
+compile in this revision of C++. For example:
 ``` cpp
 auto p = new char[100];
 char q[100];
 std::cin >> std::setw(20) >> p;         // ill-formed; previously well-formed
 **Change:** Overload resolution for ostream inserters used with UTF-8
 literals. **Rationale:** Required for new features. **Effect on original
 feature:** Valid C++17 code that passes UTF-8 literals to
 `basic_ostream<char, ...>::operator<<` or
+`basic_ostream<wchar_t, ...>::operator<<` is now ill-formed. For
+example:
 ``` cpp
 std::cout << u8"text";          // previously called operator<<(const char*) and printed a string;
                                 // now ill-formed
 std::cout << u8'X';             // previously called operator<<(char) and printed a character;
 `wchar_t`, `char16_t`, or `char32_t` types. **Rationale:** Removal of
 surprising behavior. **Effect on original feature:** Valid C++17 code
 that passes `wchar_t`, `char16_t`, or `char32_t` characters or strings
 to `basic_ostream<char, ...>::operator<<` or that passes `char16_t` or
 `char32_t` characters or strings to
+`basic_ostream<wchar_t, ...>::operator<<` is now ill-formed. For
+example:
 ``` cpp
 std::cout << u"text";           // previously formatted the string as a pointer value;
                                 // now ill-formed
 std::cout << u'X';              // previously formatted the character as an integer value;
 **Change:** Return type of filesystem path format observer member
 functions. **Rationale:** Required for new features. **Effect on
 original feature:** Valid C++17 code that depends on the `u8string()`
 and `generic_u8string()` member functions of `std::filesystem::path`
+returning `std::string` is not valid in this revision of C++. For
+example:
 ``` cpp
 std::filesystem::path p;
 std::string s1 = p.u8string();          // ill-formed; previously well-formed
 std::string s2 = p.generic_u8string();  // ill-formed; previously well-formed
 **Change:** Remove `uncaught_exception`. **Rationale:** The function did
 not have a clear specification when multiple exceptions were active, and
 has been superseded by `uncaught_exceptions`. **Effect on original
 feature:** A valid C++17 program that calls `std::uncaught_exception`
+may fail to compile. It can be revised to use `std::uncaught_exceptions`
+instead, for clear and portable semantics.
 **Change:** Remove support for adaptable function API. **Rationale:**
 The deprecated support relied on a limited convention that could not be
 extended to support the general case or new language features. It has
 been superseded by direct language support with `decltype`, and by the
 `reference`, `const_reference`, `rebind`, `address`, `construct`,
 `destroy`, or `max_size` members of `std::allocator`, or that directly
 calls `allocate` with an additional hint argument, may fail to compile.
 **Change:** Remove `raw_storage_iterator`. **Rationale:** The iterator
+encouraged use of potentially-throwing algorithms, but did not return
+the number of elements successfully constructed, as would be necessary
+to destroy them. **Effect on original feature:** A valid C++17 program
+that uses this iterator class may fail to compile.
 **Change:** Remove temporary buffers API. **Rationale:** The temporary
 buffer facility was intended to provide an efficient optimization for
 small memory requests, but there is little evidence this was achieved in
 practice, while requiring the user to provide their own exception-safe
 **Change:** Remove `shared_ptr::unique`. **Rationale:** The result of a
 call to this member function is not reliable in the presence of multiple
 threads and weak pointers. The member function `use_count` is similarly
 unreliable, but has a clearer contract in such cases, and remains
+available for well-defined use in single-threaded cases. **Effect on
 original feature:** A valid C++17 program that calls `unique` on a
 `shared_ptr` object may fail to compile.
 **Change:** Remove deprecated type traits. **Rationale:** The traits had
 unreliable or awkward interfaces. The `is_literal_type` trait provided
 no way to detect which subset of constructors and member functions of a
 type were declared `constexpr`. The `result_of` trait had a surprising
+syntax that did not directly support function types. It has been
+superseded by the `invoke_result` trait. **Effect on original feature:**
+A valid C++17 program that relies on the `is_literal_type` or
 `result_of` type traits, on the `is_literal_type_v` variable template,
 or on the `result_of_t` alias template may fail to compile.

Diff to HTML by rtfpessoa