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

Files changed (1) hide show

tmp/tmpzmv6o54t/{from.md → to.md} +129 -127

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

@@ -1,117 +1,114 @@
 ## C++ and ISO C++14 <a id="diff.cpp14">[[diff.cpp14]]</a>
 This subclause lists the differences between C++ and ISO C++14 (ISO/IEC
-14882:2014, *Programming Languages — C++*), by the chapters of this
-document.
-### Clause  [[lex]]: lexical conventions <a id="diff.cpp14.lex">[[diff.cpp14.lex]]</a>
-[[lex.phases]] **Change:** Removal of trigraph support as a required
-feature. **Rationale:** Prevents accidental uses of trigraphs in non-raw
-string literals and comments. **Effect on original feature:** Valid
-C++14code that uses trigraphs may not be valid or may have different
-semantics in this International Standard. Implementations may choose to
-translate trigraphs as specified in C++14if they appear outside of a raw
-string literal, as part of the *implementation-defined* mapping from
-physical source file characters to the basic source character set.
-[[lex.ppnumber]] **Change:** *pp-number* can contain `p` *sign* and `P`
-*sign*. **Rationale:** Necessary to enable hexadecimal floating
-literals. **Effect on original feature:** Valid C++14code may fail to
-compile or produce different results in this International Standard.
-Specifically, character sequences like `0p+0` and `0e1_p+0` are three
-separate tokens each in C++14, but one single token in this
-International Standard.
 ``` cpp
 #define F(a) b ## a
-int b0p = F(0p+0);  // ill-formed; equivalent to ``int b0p = b0p + 0;'' in C++14
 ```
-### Clause  [[expr]]: expressions <a id="diff.cpp14.expr">[[diff.cpp14.expr]]</a>
-[[expr.post.incr]], [[expr.pre.incr]] **Change:** Remove increment
-operator with `bool` operand. **Rationale:** Obsolete feature with
-occasionally surprising semantics. **Effect on original feature:** A
-valid C++14expression utilizing the increment operator on a `bool`
-lvalue is ill-formed in this International Standard. Note that this
-might occur when the lvalue has a type given by a template parameter.
-[[expr.new]], [[expr.delete]] **Change:** Dynamic allocation mechanism
-for over-aligned types. **Rationale:** Simplify use of over-aligned
-types. **Effect on original feature:** In C++14code that uses a
-*new-expression* to allocate an object with an over-aligned class type,
-where that class has no allocation functions of its own,
-`::operator new(std::size_t)` is used to allocate the memory. In this
-International Standard, `::operator new(std::size_t, std::align_val_t)`
-is used instead.
-### Clause  [[dcl.dcl]]: declarations <a id="diff.cpp14.dcl.dcl">[[diff.cpp14.dcl.dcl]]</a>
-[[dcl.stc]] **Change:** Removal of `register` *storage-class-specifier*.
 **Rationale:** Enable repurposing of deprecated keyword in future
 revisions of this International Standard. **Effect on original
 feature:** A valid C++14 declaration utilizing the `register`
 *storage-class-specifier* is ill-formed in this International Standard.
 The specifier can simply be removed to retain the original meaning.
-[[dcl.spec.auto]] **Change:** `auto` deduction from *braced-init-list*.
-**Rationale:** More intuitive deduction behavior. **Effect on original
-feature:** Valid C++14code may fail to compile or may change meaning in
-this International Standard. For example:
 ``` cpp
 auto x1{1};         // was std::initializer_list<int>, now int
 auto x2{1, 2};      // was std::initializer_list<int>, now ill-formed
 ```
-### Clause  [[dcl.decl]]: declarators <a id="diff.cpp14.decl">[[diff.cpp14.decl]]</a>
-[[dcl.fct]] **Change:** Make exception specifications be part of the
-type system. **Rationale:** Improve type-safety. **Effect on original
-feature:** Valid C++14code may fail to compile or change meaning in this
-International Standard:
 ``` cpp
 void g1() noexcept;
 void g2();
 template<class T> int f(T *, T *);
 int x = f(g1, g2);              // ill-formed; previously well-formed
 ```
-[[dcl.init.aggr]] **Change:** Definition of an aggregate is extended to
-apply to user-defined types with base classes. **Rationale:** To
-increase convenience of aggregate initialization. **Effect on original
-feature:** Valid C++14code may fail to compile or produce different
-results in this International Standard; initialization from an empty
-initializer list will perform aggregate initialization instead of
-invoking a default constructor for the affected types:
 ``` cpp
 struct derived;
 struct base {
   friend struct derived;
 private:
   base();
 };
 struct derived : base {};
-derived d1{};       // Error. The code was well-formed before.
 derived d2;         // still OK
 ```
-### Clause  [[special]]: special member functions <a id="diff.cpp14.special">[[diff.cpp14.special]]</a>
-[[class.inhctor.init]] **Change:** Inheriting a constructor no longer
-injects a constructor into the derived class. **Rationale:** Better
-interaction with other language features. **Effect on original
-feature:** Valid C++14code that uses inheriting constructors may not be
-valid or may have different semantics. A *using-declaration* that names
-a constructor now makes the corresponding base class constructors
-visible to initializations of the derived class rather than declaring
-additional derived class constructors.
 ``` cpp
 struct A {
   template<typename T> A(T, typename T::type = 0);
   A(int);
@@ -123,101 +120,106 @@ struct B : A {
 B b(42L);           // now calls B(int), used to call B<long>(long),
                     // which called A(int) due to substitution failure
                     // in A<long>(long).
 ```
-### Clause  [[temp]]: templates <a id="diff.cpp14.temp">[[diff.cpp14.temp]]</a>
-[[temp.deduct.type]] **Change:** Allowance to deduce from the type of a
-non-type template argument. **Rationale:** In combination with the
-ability to declare non-type template arguments with placeholder types,
-allows partial specializations to decompose from the type deduced for
-the non-type template argument. **Effect on original feature:** Valid
-C++14code may fail to compile or produce different results in this
-International Standard:
 ``` cpp
 template <int N> struct A;
 template <typename T, T N> int foo(A<N> *) = delete;
 void foo(void *);
 void bar(A<0> *p) {
   foo(p);           // ill-formed; previously well-formed
 }
 ```
-### Clause  [[except]]: exception handling <a id="diff.cpp14.except">[[diff.cpp14.except]]</a>
-[[except.spec]] **Change:** Remove dynamic exception specifications.
-**Rationale:** Dynamic exception specifications were a deprecated
-feature that was complex and brittle in use. They interacted badly with
-the type system, which became a more significant issue in this
-International Standard where (non-dynamic) exception specifications are
-part of the function type. **Effect on original feature:** A valid
-C++14function declaration, member function declaration, function pointer
-declaration, or function reference declaration, if it has a potentially
-throwing dynamic exception specification, will be rejected as ill-formed
-in this International Standard. Violating a non-throwing dynamic
-exception specification will call `terminate` rather than `unexpected`
-and might not perform stack unwinding prior to such a call.
-### Clause  [[library]]: library introduction <a id="diff.cpp14.library">[[diff.cpp14.library]]</a>
-[[namespace.future]] **Change:** New reserved namespaces. **Rationale:**
-Reserve namespaces for future revisions of the standard library that
-might otherwise be incompatible with existing programs. **Effect on
-original feature:** The global namespaces `std` followed by an arbitrary
-sequence of digits is reserved for future standardization. Valid
-C++14code that uses such a top-level namespace, e.g., `std2`, may be
-invalid in this International Standard.
-### Clause  [[utilities]]: general utilities library <a id="diff.cpp14.utilities">[[diff.cpp14.utilities]]</a>
-[[func.wrap]] **Change:** Constructors taking allocators removed.
-**Rationale:** No implementation consensus. **Effect on original
 feature:** Valid C++14 code may fail to compile or may change meaning in
-this International Standard. Specifically, constructing a
-`std::function` with an allocator is ill-formed and uses-allocator
-construction will not pass an allocator to `std::function` constructors
-in this International Standard.
-[[util.smartptr.shared]] **Change:** Different constraint on conversions
-from `unique_ptr`. **Rationale:** Adding array support to `shared_ptr`,
-via the syntax `shared_ptr<T[]>` and `shared_ptr<T[N]>`. **Effect on
-original feature:** Valid C++14code may fail to compile or may change
-meaning in this International Standard. For example:
 ``` cpp
 #include <memory>
 std::unique_ptr<int[]> arr(new int[1]);
 std::shared_ptr<int> ptr(std::move(arr));   // error: int(*)[] is not compatible with int*
 ```
-### Clause  [[strings]]: strings library <a id="diff.cpp14.string">[[diff.cpp14.string]]</a>
-[[basic.string]] **Change:** Non-const `.data()` member added.
-**Rationale:** The lack of a non-const `.data()` differed from the
-similar member of `std::vector`. This change regularizes behavior for
-this International Standard. **Effect on original feature:** Overloaded
-functions which have differing code paths for `char*` and `const char*`
-arguments will execute differently when called with a non-const string’s
-`.data()` member in this International Standard.
 ``` cpp
 int f(char *) = delete;
 int f(const char *);
 string s;
 int x = f(s.data());            // ill-formed; previously well-formed
 ```
-### Clause  [[containers]]: containers library <a id="diff.cpp14.containers">[[diff.cpp14.containers]]</a>
-[[associative.reqmts]] **Change:** Requirements change: **Rationale:**
-Increase portability, clarification of associative container
-requirements. **Effect on original feature:** Valid C++14code that
-attempts to use associative containers having a comparison object with
-non-const function call operator may fail to compile in this
-International Standard:
 ``` cpp
 #include <set>
 struct compare
@@ -232,21 +234,21 @@ int main() {
   const std::set<int, compare> s;
   s.find(0);
 }
 ```
-### Annex  [[depr]]: compatibility features <a id="diff.cpp14.depr">[[diff.cpp14.depr]]</a>
 **Change:** The class templates `auto_ptr`, `unary_function`, and
 `binary_function`, the function templates `random_shuffle`, and the
 function templates (and their return types) `ptr_fun`, `mem_fun`,
 `mem_fun_ref`, `bind1st`, and `bind2nd` are not defined. **Rationale:**
-Superseded by new features. **Effect on original feature:** Valid
-C++14code that uses these class templates and function templates may
-fail to compile in this International Standard.
 **Change:** Remove old iostreams members \[depr.ios.members\].
 **Rationale:** Redundant feature for compatibility with pre-standard
-code has served its time. **Effect on original feature:** A valid
-C++14program using these identifiers may be ill-formed in this
-International Standard.

 ## C++ and ISO C++14 <a id="diff.cpp14">[[diff.cpp14]]</a>
 This subclause lists the differences between C++ and ISO C++14 (ISO/IEC
+14882:2014, *Programming Languages — C++*), in addition to those listed
+above, by the chapters of this document.
+###  [[lex]]: lexical conventions <a id="diff.cpp14.lex">[[diff.cpp14.lex]]</a>
+**Change:** Removal of trigraph support as a required feature.
+**Rationale:** Prevents accidental uses of trigraphs in non-raw string
+literals and comments. **Effect on original feature:** Valid C++14 code
+that uses trigraphs may not be valid or may have different semantics in
+this International Standard. Implementations may choose to translate
+trigraphs as specified in C++14 if they appear outside of a raw string
+literal, as part of the *implementation-defined* mapping from physical
+source file characters to the basic source character set.
+**Change:** *pp-number* can contain `p` *sign* and `P` *sign*.
+**Rationale:** Necessary to enable
+*hexadecimal-floating-point-literal*s. **Effect on original feature:**
+Valid C++14 code may fail to compile or produce different results in
+this International Standard. Specifically, character sequences like
+`0p+0` and `0e1_p+0` are three separate tokens each in C++14, but one
+single token in this International Standard. For example:
 ``` cpp
 #define F(a) b ## a
+int b0p = F(0p+0);  // ill-formed; equivalent to ``int b0p = b0p + 0;'' in C++14{}
 ```
+###  [[expr]]: expressions <a id="diff.cpp14.expr">[[diff.cpp14.expr]]</a>
+**Change:** Remove increment operator with `bool` operand.
+**Rationale:** Obsolete feature with occasionally surprising semantics.
+**Effect on original feature:** A valid C++14 expression utilizing the
+increment operator on a `bool` lvalue is ill-formed in this
+International Standard. Note that this might occur when the lvalue has a
+type given by a template parameter.
+**Change:** Dynamic allocation mechanism for over-aligned types.
+**Rationale:** Simplify use of over-aligned types. **Effect on original
+feature:** In C++14 code that uses a *new-expression* to allocate an
+object with an over-aligned class type, where that class has no
+allocation functions of its own, `::operator new(std::size_t)` is used
+to allocate the memory. In this International Standard,
+`::operator new(std::size_t, std::align_val_t)` is used instead.
+###  [[dcl.dcl]]: declarations <a id="diff.cpp14.dcl.dcl">[[diff.cpp14.dcl.dcl]]</a>
+**Change:** Removal of `register` *storage-class-specifier*.
 **Rationale:** Enable repurposing of deprecated keyword in future
 revisions of this International Standard. **Effect on original
 feature:** A valid C++14 declaration utilizing the `register`
 *storage-class-specifier* is ill-formed in this International Standard.
 The specifier can simply be removed to retain the original meaning.
+**Change:** `auto` deduction from *braced-init-list*. **Rationale:**
+More intuitive deduction behavior. **Effect on original feature:** Valid
+C++14 code may fail to compile or may change meaning in this
+International Standard. For example:
 ``` cpp
 auto x1{1};         // was std::initializer_list<int>, now int
 auto x2{1, 2};      // was std::initializer_list<int>, now ill-formed
 ```
+**Change:** Make exception specifications be part of the type system.
+**Rationale:** Improve type-safety. **Effect on original feature:**
+Valid C++14 code may fail to compile or change meaning in this
+International Standard. For example:
 ``` cpp
 void g1() noexcept;
 void g2();
 template<class T> int f(T *, T *);
 int x = f(g1, g2);              // ill-formed; previously well-formed
 ```
+**Change:** Definition of an aggregate is extended to apply to
+user-defined types with base classes. **Rationale:** To increase
+convenience of aggregate initialization. **Effect on original feature:**
+Valid C++14 code may fail to compile or produce different results in
+this International Standard; initialization from an empty initializer
+list will perform aggregate initialization instead of invoking a default
+constructor for the affected types. For example:
 ``` cpp
 struct derived;
 struct base {
   friend struct derived;
 private:
   base();
 };
 struct derived : base {};
+derived d1{};       // error; the code was well-formed in C++14{}
 derived d2;         // still OK
 ```
+###  [[class]]: classes <a id="diff.cpp14.class">[[diff.cpp14.class]]</a>
+**Change:** Inheriting a constructor no longer injects a constructor
+into the derived class. **Rationale:** Better interaction with other
+language features. **Effect on original feature:** Valid C++14 code that
+uses inheriting constructors may not be valid or may have different
+semantics. A *using-declaration* that names a constructor now makes the
+corresponding base class constructors visible to initializations of the
+derived class rather than declaring additional derived class
+constructors.
 ``` cpp
 struct A {
   template<typename T> A(T, typename T::type = 0);
   A(int);
 B b(42L);           // now calls B(int), used to call B<long>(long),
                     // which called A(int) due to substitution failure
                     // in A<long>(long).
 ```
+###  [[temp]]: templates <a id="diff.cpp14.temp">[[diff.cpp14.temp]]</a>
+**Change:** Allowance to deduce from the type of a non-type template
+argument. **Rationale:** In combination with the ability to declare
+non-type template arguments with placeholder types, allows partial
+specializations to decompose from the type deduced for the non-type
+template argument. **Effect on original feature:** Valid C++14 code may
+fail to compile or produce different results in this International
+Standard. For example:
 ``` cpp
 template <int N> struct A;
 template <typename T, T N> int foo(A<N> *) = delete;
 void foo(void *);
 void bar(A<0> *p) {
   foo(p);           // ill-formed; previously well-formed
 }
 ```
+###  [[except]]: exception handling <a id="diff.cpp14.except">[[diff.cpp14.except]]</a>
+**Change:** Remove dynamic exception specifications. **Rationale:**
+Dynamic exception specifications were a deprecated feature that was
+complex and brittle in use. They interacted badly with the type system,
+which became a more significant issue in this International Standard
+where (non-dynamic) exception specifications are part of the function
+type. **Effect on original feature:** A valid C++14 function
+declaration, member function declaration, function pointer declaration,
+or function reference declaration, if it has a potentially throwing
+dynamic exception specification, will be rejected as ill-formed in this
+International Standard. Violating a non-throwing dynamic exception
+specification will call `terminate` rather than `unexpected` and might
+not perform stack unwinding prior to such a call.
+###  [[library]]: library introduction <a id="diff.cpp14.library">[[diff.cpp14.library]]</a>
+**Change:** New headers. **Rationale:** New functionality. **Effect on
+original feature:** The following C++ headers are new: `<any>`,
+`<charconv>`, `<execution>`, `<filesystem>`, `<memory_resource>`,
+`<optional>`,
+`<string_view>`, and `<variant>`. Valid C++14 code that `#include`s
+headers with these names may be invalid in this International Standard.
+**Change:** New reserved namespaces. **Rationale:** Reserve namespaces
+for future revisions of the standard library that might otherwise be
+incompatible with existing programs. **Effect on original feature:** The
+global namespaces `std` followed by an arbitrary sequence of *digit*s
+[[lex.name]] are reserved for future standardization. Valid C++14 code
+that uses such a top-level namespace, e.g., `std2`, may be invalid in
+this International Standard.
+###  [[utilities]]: general utilities library <a id="diff.cpp14.utilities">[[diff.cpp14.utilities]]</a>
+**Change:** Constructors taking allocators removed. **Rationale:** No
+implementation consensus. **Effect on original feature:** Valid C++14
+code may fail to compile or may change meaning in this International
+Standard. Specifically, constructing a `std::function` with an allocator
+is ill-formed and uses-allocator construction will not pass an allocator
+to `std::function` constructors in this International Standard.
+**Change:** Different constraint on conversions from `unique_ptr`.
+**Rationale:** Adding array support to `shared_ptr`, via the syntax
+`shared_ptr<T[]>` and `shared_ptr<T[N]>`. **Effect on original
 feature:** Valid C++14 code may fail to compile or may change meaning in
+this International Standard. For example:
 ``` cpp
 #include <memory>
 std::unique_ptr<int[]> arr(new int[1]);
 std::shared_ptr<int> ptr(std::move(arr));   // error: int(*)[] is not compatible with int*
 ```
+###  [[strings]]: strings library <a id="diff.cpp14.string">[[diff.cpp14.string]]</a>
+**Change:** Non-const `.data()` member added. **Rationale:** The lack of
+a non-const `.data()` differed from the similar member of `std::vector`.
+This change regularizes behavior for this International Standard.
+**Effect on original feature:** Overloaded functions which have
+differing code paths for `char*` and `const char*` arguments will
+execute differently when called with a non-const string’s `.data()`
+member in this International Standard.
 ``` cpp
 int f(char *) = delete;
 int f(const char *);
 string s;
 int x = f(s.data());            // ill-formed; previously well-formed
 ```
+###  [[containers]]: containers library <a id="diff.cpp14.containers">[[diff.cpp14.containers]]</a>
+**Change:** Requirements change: **Rationale:** Increase portability,
+clarification of associative container requirements. **Effect on
+original feature:** Valid C++14 code that attempts to use associative
+containers having a comparison object with non-const function call
+operator may fail to compile in this International Standard:
 ``` cpp
 #include <set>
 struct compare
   const std::set<int, compare> s;
   s.find(0);
 }
 ```
+### [[depr]]: compatibility features <a id="diff.cpp14.depr">[[diff.cpp14.depr]]</a>
 **Change:** The class templates `auto_ptr`, `unary_function`, and
 `binary_function`, the function templates `random_shuffle`, and the
 function templates (and their return types) `ptr_fun`, `mem_fun`,
 `mem_fun_ref`, `bind1st`, and `bind2nd` are not defined. **Rationale:**
+Superseded by new features. **Effect on original feature:** Valid C++14
+code that uses these class templates and function templates may fail to
+compile in this International Standard.
 **Change:** Remove old iostreams members \[depr.ios.members\].
 **Rationale:** Redundant feature for compatibility with pre-standard
+code has served its time. **Effect on original feature:** A valid C++14
+program using these identifiers may be ill-formed in this International
+Standard.

Diff to HTML by rtfpessoa