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

Files changed (1) hide show

tmp/tmpcaxjnvw_/{from.md → to.md} +528 -0

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

	@@ -0,0 +1,528 @@

+## 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
+  [[temp.concept]].
+- The `consteval` keyword is added to declare immediate functions
+  [[dcl.constexpr]].
+- The `constinit` keyword is added to prevent unintended dynamic
+  initialization [[dcl.constinit]].
+- The `co_await`, `co_yield`, and `co_return` keywords are added to
+  enable the definition of coroutines [[dcl.fct.def.coroutine]].
+- The `requires` keyword is added to introduce constraints through a
+  *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);
+  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 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
+auto u8c = u8'c';               // u8c previously deduced as char; now deduced as 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.
+```
+###  [[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,
+then reading the latter value with a `memory_order_acquire` load no
+longer provides any “happens before” guarantees, even in the absence of
+intervening stores by another thread.
+###  [[expr]]: expressions <a id="diff.cpp17.expr">[[diff.cpp17.expr]]</a>
+**Change:** Implicit lambda capture may capture additional entities.
+**Rationale:** Rule simplification, necessary to resolve interactions
+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 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(); }
+// Translation unit 2
+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 International Standard.
+``` cpp
+struct A {              // not an aggregate; previously an aggregate
+  A() = delete;
+};
+struct B {              // not an aggregate; previously an aggregate
+  B() = default;
+  int i = 0;
+};
+struct C {              // not an aggregate; previously an aggregate
+  C(C&&) = default;
+  int a, b;
+};
+A a{};                  // ill-formed; previously well-formed
+B b = {1};              // ill-formed; previously well-formed
+auto* c = new C{2, 3};  // ill-formed; previously well-formed
+struct Y;
+struct X {
+  operator Y();
+};
+struct Y {              // not an aggregate; previously an aggregate
+  Y(const Y&) = default;
+  X x;
+};
+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
+International Standard. 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 International Standard. 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 International
+Standard. 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 International Standard. For example:
+``` cpp
+struct base {
+  base();
+  base(base const &);
+private:
+  base(base &&);
+};
+struct derived : base {};
+base f(base b) {
+  throw b;                      // error: base(base &&) is private
+  derived d;
+  return d;                     // error: base(base &&) is private
+}
+struct S {
+  S(const char *s) : m(s) { }
+  S(const S&) = default;
+  S(S&& other) : m(other.m) { other.m = nullptr; }
+  const char * m;
+};
+S consume(S&& s) { return s; }
+void g() {
+  S s("text");
+  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:**
+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;
+};
+bool operator==(A, int);        // #1
+// #2 is built-in candidate: bool operator==(int, int);
+// #3 is built-in candidate: bool operator!=(int, int);
+int check(A x, A y) {
+  return (x == y) +             // ill-formed; previously well-formed
+    (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:
+`<ccomplex>`, `<ciso646>`, `<cstdalign>`, `<cstdbool>`, and `<ctgmath>`.
+To retain the same behavior:
+- a `#include` of `<ccomplex>` can be replaced by a `#include` of
+  `<complex>`,
+- a `#include` of `<ctgmath>` can be replaced by a `#include` of
+  `<cmath>` and a `#include` of `<complex>`, and
+- a `#include` of `<ciso646>`, `<cstdalign>`, or `<cstdbool>` can simply
+  be removed.
+###  [[containers]]: containers library <a id="diff.cpp17.containers">[[diff.cpp17.containers]]</a>
+**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.
+**Rationale:** Corrects an issue misidentifying pointer types that are
+not incrementable as iterator types. **Effect on original feature:** A
+valid C++17 program that relies on the presence of the typedefs may fail
+to compile, or have different behavior.
+###  [[algorithms]]: algorithms library <a id="diff.cpp17.alg.reqs">[[diff.cpp17.alg.reqs]]</a>
+**Change:** The number and order of deducible template parameters for
+algorithm declarations is now unspecified, instead of being as-declared.
+**Rationale:** Increase implementor freedom and allow some function
+templates to be implemented as function objects with templated call
+operators. **Effect on original feature:** A valid C++17 program that
+passes explicit template arguments to algorithms not explicitly
+specified to allow such in this version of C++ may fail to compile or
+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
+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;
+                                // 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.
+``` 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 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
+```
+###  [[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
+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
+`std::bind` and `std::not_fn` function templates. **Effect on original
+feature:** A valid C++17 program that relies on the presence of
+`result_type`, `argument_type`, `first_argument_type`, or
+`second_argument_type` in a standard library class may fail to compile.
+A valid C++17 program that calls `not1` or `not2`, or uses the class
+templates `unary_negate` or `binary_negate`, may fail to compile.
+**Change:** Remove redundant members from `std::allocator`.
+**Rationale:** `std::allocator` was overspecified, encouraging direct
+usage in user containers rather than relying on `std::allocator_traits`,
+leading to poor containers. **Effect on original feature:** A valid
+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
+wrappers to guard use of the facility in many cases. **Effect on
+original feature:** A valid C++17 program that calls
+`get_temporary_buffer` or `return_temporary_buffer` may fail to compile.
+**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.

Diff to HTML by rtfpessoa