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

Files changed (1) hide show

tmp/tmpxzlqjy90/{from.md → to.md} +107 -39

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

@@ -1,19 +1,21 @@
 ## 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
@@ -21,21 +23,27 @@ 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
@@ -55,29 +63,34 @@ Valid C++17 code using `char8_t`, `concept`, `consteval`, `constinit`,
 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);
   template<bool(X, X)> struct Y {};
   Y<operator<=> y;              // ill-formed; previously well-formed
 }
 ```
 **Change:** Type of UTF-8 string and character literals. **Rationale:**
 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
@@ -94,27 +107,32 @@ template<> struct ct<char> {
   using type = char;
 };
 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 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,
@@ -129,28 +147,33 @@ intervening stores by another thread.
 with constexpr if. **Effect on original feature:** Lambdas with a
 *capture-default* may capture local entities that were not captured in
 C++17 if those entities are only referenced in contexts that do not
 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 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(); }
@@ -159,17 +182,20 @@ int g() { return f(); }
 int f(int a = 76) { return a; }         // ill-formed, no diagnostic required; previously well-formed
 int g();
 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 revision of C++. For
-example:
 ``` cpp
 struct A {              // not an aggregate; previously an aggregate
   A() = delete;
 };
@@ -200,59 +226,74 @@ struct Y {              // not an aggregate; previously an aggregate
 };
 Y y{X{}};               // copy constructor call; previously aggregate-initialization
 ```
 **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
 ```
 ###  [[class]]: classes <a id="diff.cpp17.class">[[diff.cpp17.class]]</a>
 **Change:** The class name can no longer be used parenthesized
 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
   explicit(true) (S)(int);      // OK
 };
 ```
 **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(int);           // OK, injected-class-name used
   ~A<T>();          // error: simple-template-id not allowed for destructor
 };
 ```
 **Change:** A function returning an implicitly movable entity may invoke
 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 &);
@@ -282,21 +323,25 @@ void g() {
   consume(static_cast<S&&>(s));
   char c = *s.m;                // undefined behavior; previously ok
 }
 ```
 ###  [[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;
 };
@@ -310,15 +355,19 @@ int check(A x, A y) {
     (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; }
 };
@@ -332,21 +381,25 @@ struct B {
 };
 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() {}
@@ -355,10 +408,12 @@ int main() {
   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,
@@ -431,62 +486,75 @@ 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 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
 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. 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;
                                 // now ill-formed
 ```
 **Change:** Overload resolution for ostream inserters used with
 `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;
                                 // now ill-formed
 ```
 **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
 ```
 ###  [[depr]]: compatibility features <a id="diff.cpp17.depr">[[diff.cpp17.depr]]</a>
 **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
@@ -536,13 +604,13 @@ 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.

 ## 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, in addition to those listed above, 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++.
+[*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 module-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
 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++.
+[*Example 3*:
 ``` cpp
 namespace N {
   struct X {};
   bool operator<=(X, X);
   template<bool(X, X)> struct Y {};
   Y<operator<=> y;              // ill-formed; previously well-formed
 }
 ```
+— *end example*]
 **Change:** Type of UTF-8 string and character literals. **Rationale:**
 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++.
+[*Example 4*:
 ``` 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
   using type = char;
 };
 ct<decltype(u8'c')>::type x;    // ill-formed; previously well-formed.
 ```
+— *end example*]
 ###  [[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++.
+[*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,
 with constexpr if. **Effect on original feature:** Lambdas with a
 *capture-default* may capture local entities that were not captured in
 C++17 if those entities are only referenced in contexts that do not
 result in an odr-use.
+###  [[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++.
+[*Example 1*:
 ``` cpp
 typedef struct {
   void f() {}           // ill-formed; previously well-formed
 } S;
 ```
+— *end example*]
 **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.
+[*Example 2*:
 ``` cpp
 // Translation unit 1
 int f(int a = 42);
 int g() { return f(); }
 int f(int a = 76) { return a; }         // ill-formed, no diagnostic required; previously well-formed
 int g();
 int main() { return g(); }              // used to return 42
 ```
+— *end example*]
 **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++.
+[*Example 3*:
 ``` cpp
 struct A {              // not an aggregate; previously an aggregate
   A() = delete;
 };
 };
 Y y{X{}};               // copy constructor call; previously aggregate-initialization
 ```
+— *end example*]
 **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++.
+[*Example 4*:
 ``` cpp
 bool y[] = { "bc" };    // ill-formed; previously well-formed
 ```
+— *end example*]
 ###  [[class]]: classes <a id="diff.cpp17.class">[[diff.cpp17.class]]</a>
 **Change:** The class name can no longer be used parenthesized
 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++.
+[*Example 1*:
 ``` cpp
 struct S {
   explicit (S)(const S&);       // ill-formed; previously well-formed
   explicit (operator int)();    // ill-formed; previously well-formed
   explicit(true) (S)(int);      // OK
 };
 ```
+— *end example*]
 **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++.
+[*Example 2*:
 ``` cpp
 template<class T>
 struct A {
   A<T>();           // error: simple-template-id not allowed for constructor
   A(int);           // OK, injected-class-name used
   ~A<T>();          // error: simple-template-id not allowed for destructor
 };
 ```
+— *end example*]
 **Change:** A function returning an implicitly movable entity may invoke
 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++.
+[*Example 3*:
 ``` cpp
 struct base {
   base();
   base(base const &);
   consume(static_cast<S&&>(s));
   char c = *s.m;                // undefined behavior; previously ok
 }
 ```
+— *end example*]
 ###  [[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.
+[*Example 1*:
 ``` cpp
 struct A {
   operator int() const;
 };
     (10 == x) +                 // calls #1, previously selected #2
     (10 != x);                  // calls #1, previously selected #3
 }
 ```
+— *end example*]
 **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++.
+[*Example 2*:
 ``` cpp
 struct A {
   operator int() const { return 10; }
 };
 };
 B b1;
 bool eq = (b1 == b1);           // ambiguous; previously well-formed
 ```
+— *end example*]
 ###  [[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.
+[*Example 1*:
 ``` cpp
 struct A {};
 bool operator<(void (*fp)(), A);
 void f() {}
   f < a;    // ill-formed; previously well-formed
   (f) < a;  // still well-formed
 }
 ```
+— *end example*]
 ###  [[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,
 ###  [[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++.
+[*Example 1*:
 ``` cpp
 auto p = new char[100];
 char q[100];
 std::cin >> std::setw(20) >> p;         // ill-formed; previously well-formed
 std::cin >> std::setw(20) >> q;         // OK
 ```
+— *end example*]
 **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.
+[*Example 2*:
 ``` 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;
                                 // now ill-formed
 ```
+— *end example*]
 **Change:** Overload resolution for ostream inserters used with
 `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.
+[*Example 3*:
 ``` 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;
                                 // now ill-formed
 ```
+— *end example*]
 **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++.
+[*Example 4*:
 ``` 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
 ```
+— *end example*]
 ###  [[depr]]: compatibility features <a id="diff.cpp17.depr">[[diff.cpp17.depr]]</a>
 **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
 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 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