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

Files changed (1) hide show

tmp/tmpv0mbhno9/{from.md → to.md} +53 -52

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

@@ -1,29 +1,31 @@
 ## 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{}
 ```
@@ -31,45 +33,44 @@ 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 *);
@@ -78,12 +79,12 @@ 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 {
@@ -104,11 +105,11 @@ 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);
@@ -127,12 +128,12 @@ B b(42L);           // now calls B(int), used to call B<long>(long),
 **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 *);
@@ -144,51 +145,51 @@ void bar(A<0> *p) {
 ###  [[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*
@@ -196,15 +197,15 @@ std::shared_ptr<int> ptr(std::move(arr));   // error: int(*)[] is not compatible
 ###  [[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;
@@ -215,11 +216,11 @@ int x = f(s.data());            // ill-formed; previously well-formed
 **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
@@ -242,13 +243,13 @@ int main() {
 `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.

 ## C++ and ISO C++14 <a id="diff.cpp14">[[diff.cpp14]]</a>
+### General <a id="diff.cpp14.general">[[diff.cpp14.general]]</a>
+Subclause [[diff.cpp14]] 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 revision of C++. 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 input source file
+characters to the translation 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 revision of C++. Specifically, character sequences like `0p+0` and
+`0e1_p+0` are three separate tokens each in C++14, but one single token
+in this revision of C++. 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 revision of
+C++.
 **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 revision of C++,
 `::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 C++. **Effect on original feature:** A valid C++14
+declaration utilizing the `register` *storage-class-specifier* is
+ill-formed in this revision of C++. 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 revision of
+C++. 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 revision
+of C++. For example:
 ``` cpp
 void g1() noexcept;
 void g2();
 template<class T> int f(T *, T *);
 **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 revision of C++; 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 {
 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. For example:
 ``` cpp
 struct A {
   template<typename T> A(T, typename T::type = 0);
   A(int);
 **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 revision of C++.
+For example:
 ``` cpp
 template <int N> struct A;
 template <typename T, T N> int foo(A<N> *) = delete;
 void foo(void *);
 ###  [[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 revision of C++ 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, is rejected as ill-formed in this revision of
+C++. Violating a non-throwing dynamic exception specification calls
+`terminate` rather than `unexpected`, and it is unspecified whether
+stack unwinding is performed 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 revision of C++.
 **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 revision of C++.
 ###  [[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 revision of C++.
+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 revision of C++.
 **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 revision of C++. 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. **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 revision of C++. For
+example:
 ``` cpp
 int f(char *) = delete;
 int f(const char *);
 string s;
 **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 revision of C++. For example:
 ``` cpp
 #include <set>
 struct compare
 `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 revision of C++.
 **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 revision of
+C++.

Diff to HTML by rtfpessoa