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

Files changed (1) hide show

tmp/tmpwe0oowo1/{from.md → to.md} +55 -57

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

@@ -1,58 +1,58 @@
 ## C++ and ISO C++11 <a id="diff.cpp11">[[diff.cpp11]]</a>
 This subclause lists the differences between C++ and ISO C++11 (ISO/IEC
-14882:2011, *Programming Languages — C++*), by the chapters of this
-document.
-### Clause  [[lex]]: lexical conventions <a id="diff.cpp11.lex">[[diff.cpp11.lex]]</a>
-[[lex.ppnumber]] **Change:** *pp-number* can contain one or more single
-quotes. **Rationale:** Necessary to enable single quotes as digit
-separators. **Effect on original feature:** Valid C++11code may fail to
-compile or may change meaning in this International Standard. For
-example, the following code is valid both in C++11and in this
-International Standard, but the macro invocation produces different
-outcomes because the single quotes delimit a character literal in C++11,
-whereas they are digit separators in this International Standard:
 ``` cpp
 #define M(x, ...) __VA_ARGS__
 int x[2] = { M(1'2,3'4, 5) };
-// int x[2] = { 5 \ \ \ \ \ } --- C++11
 // int x[2] = { 3'4, 5 } --- this International Standard
 ```
-### Clause  [[basic]]: basic concepts <a id="diff.cpp11.basic">[[diff.cpp11.basic]]</a>
-[[basic.stc.dynamic.deallocation]] **Change:** New usual (non-placement)
-deallocator. **Rationale:** Required for sized deallocation. **Effect on
-original feature:** Valid C++11code could declare a global placement
-allocation function and deallocation function as follows:
 ``` cpp
 void* operator new(std::size_t, std::size_t);
 void operator delete(void*, std::size_t) noexcept;
 ```
 In this International Standard, however, the declaration of
 `operator delete` might match a predefined usual (non-placement)
-`operator delete` ([[basic.stc.dynamic]]). If so, the program is
 ill-formed, as it was for class member allocation functions and
-deallocation functions ([[expr.new]]).
-### Clause  [[expr]]: expressions <a id="diff.cpp11.expr">[[diff.cpp11.expr]]</a>
-[[expr.cond]] **Change:** A conditional expression with a throw
-expression as its second or third operand keeps the type and value
-category of the other operand. **Rationale:** Formerly mandated
-conversions (lvalue-to-rvalue ([[conv.lval]]), array-to-pointer (
-[[conv.array]]), and function-to-pointer ([[conv.func]]) standard
-conversions), especially the creation of the temporary due to
-lvalue-to-rvalue conversion, were considered gratuitous and surprising.
-**Effect on original feature:** Valid C++11code that relies on the
-conversions may behave differently in this International Standard:
 ``` cpp
 struct S {
   int x = 1;
   void mf() { x = 2; }
@@ -72,57 +72,55 @@ sizeof(true ? "" : throw 0)
 ```
 In C++11, the expression yields `sizeof(const char*)`. In this
 International Standard, it yields `sizeof(const char[1])`.
-### Clause  [[dcl.dcl]]: declarations <a id="diff.cpp11.dcl.dcl">[[diff.cpp11.dcl.dcl]]</a>
-[[dcl.constexpr]] **Change:** `constexpr` non-static member functions
-are not implicitly `const` member functions. **Rationale:** Necessary to
-allow `constexpr` member functions to mutate the object. **Effect on
-original feature:** Valid C++11code may fail to compile in this
-International Standard. For example, the following code is valid in
-C++11 but invalid in this International Standard because it declares the
-same member function twice with different return types:
 ``` cpp
 struct S {
   constexpr const int &f();
   int &f();
 };
 ```
-### Clause  [[dcl.decl]]: declarators <a id="diff.cpp11.dcl.decl">[[diff.cpp11.dcl.decl]]</a>
-[[dcl.init.aggr]] **Change:** Classes with default member initializers
-can be aggregates. **Rationale:** Necessary to allow default member
-initializers to be used by aggregate initialization. **Effect on
-original feature:** Valid C++11code may fail to compile or may change
-meaning in this International Standard.
 ``` cpp
-struct S { // Aggregate in C++14onwards.
   int m = 1;
 };
 struct X {
   operator int();
   operator S();
 };
 X a{};
-S b{a}; // uses copy constructor in C++11,
                     // performs aggregate initialization in this International Standard
 ```
-### Clause  [[library]]: library introduction <a id="diff.cpp11.library">[[diff.cpp11.library]]</a>
-[[headers]] **Change:** New header. **Rationale:** New functionality.
-**Effect on original feature:** The C++header `<shared_mutex>` is new.
-Valid C++11code that `#include`s a header with that name may be invalid
-in this International Standard.
-### Clause  [[input.output]]: input/output library <a id="diff.cpp11.input.output">[[diff.cpp11.input.output]]</a>
-[[c.files]] **Change:** `gets` is not defined. **Rationale:** Use of
-`gets` is considered dangerous. **Effect on original feature:** Valid
-C++11code that uses the `gets` function may fail to compile in this
 International Standard.

 ## C++ and ISO C++11 <a id="diff.cpp11">[[diff.cpp11]]</a>
 This subclause lists the differences between C++ and ISO C++11 (ISO/IEC
+14882:2011, *Programming Languages — C++*), in addition to those listed
+above, by the chapters of this document.
+###  [[lex]]: lexical conventions <a id="diff.cpp11.lex">[[diff.cpp11.lex]]</a>
+**Change:** *pp-number* can contain one or more single quotes.
+**Rationale:** Necessary to enable single quotes as digit separators.
+**Effect on original feature:** Valid C++11 code may fail to compile or
+may change meaning in this International Standard. For example, the
+following code is valid both in C++11 and in this International
+Standard, but the macro invocation produces different outcomes because
+the single quotes delimit a *character-literal* in C++11, whereas they
+are digit separators in this International Standard:
 ``` cpp
 #define M(x, ...) __VA_ARGS__
 int x[2] = { M(1'2,3'4, 5) };
+// int x[2] = { 5 \ \ \ \ \ } --- C++11{}
 // int x[2] = { 3'4, 5 } --- this International Standard
 ```
+###  [[basic]]: basics <a id="diff.cpp11.basic">[[diff.cpp11.basic]]</a>
+**Change:** New usual (non-placement) deallocator. **Rationale:**
+Required for sized deallocation. **Effect on original feature:** Valid
+C++11 code could declare a global placement allocation function and
+deallocation function as follows:
 ``` cpp
 void* operator new(std::size_t, std::size_t);
 void operator delete(void*, std::size_t) noexcept;
 ```
 In this International Standard, however, the declaration of
 `operator delete` might match a predefined usual (non-placement)
+`operator delete` [[basic.stc.dynamic]]. If so, the program is
 ill-formed, as it was for class member allocation functions and
+deallocation functions [[expr.new]].
+###  [[expr]]: expressions <a id="diff.cpp11.expr">[[diff.cpp11.expr]]</a>
+**Change:** A conditional expression with a throw expression as its
+second or third operand keeps the type and value category of the other
+operand. **Rationale:** Formerly mandated conversions (lvalue-to-rvalue
+[[conv.lval]], array-to-pointer [[conv.array]], and function-to-pointer
+[[conv.func]] standard conversions), especially the creation of the
+temporary due to lvalue-to-rvalue conversion, were considered gratuitous
+and surprising. **Effect on original feature:** Valid C++11 code that
+relies on the conversions may behave differently in this International
+Standard:
 ``` cpp
 struct S {
   int x = 1;
   void mf() { x = 2; }
 ```
 In C++11, the expression yields `sizeof(const char*)`. In this
 International Standard, it yields `sizeof(const char[1])`.
+###  [[dcl.dcl]]: declarations <a id="diff.cpp11.dcl.dcl">[[diff.cpp11.dcl.dcl]]</a>
+**Change:** `constexpr` non-static member functions are not implicitly
+`const` member functions. **Rationale:** Necessary to allow `constexpr`
+member functions to mutate the object. **Effect on original feature:**
+Valid C++11 code may fail to compile in this International Standard. For
+example, the following code is valid in C++11 but invalid in this
+International Standard because it declares the same member function
+twice with different return types:
 ``` cpp
 struct S {
   constexpr const int &f();
   int &f();
 };
 ```
+**Change:** Classes with default member initializers can be aggregates.
+**Rationale:** Necessary to allow default member initializers to be used
+by aggregate initialization. **Effect on original feature:** Valid C++11
+code may fail to compile or may change meaning in this International
+Standard. For example:
 ``` cpp
+struct S { // Aggregate in C++14{} onwards.
   int m = 1;
 };
 struct X {
   operator int();
   operator S();
 };
 X a{};
+S b{a}; // uses copy constructor in C++11{},
                     // performs aggregate initialization in this International Standard
 ```
+###  [[library]]: library introduction <a id="diff.cpp11.library">[[diff.cpp11.library]]</a>
+**Change:** New header. **Rationale:** New functionality. **Effect on
+original feature:** The C++ header `<shared_mutex>` is new. Valid C++11
+code that `#include`s a header with that name may be invalid in this
 International Standard.
+###  [[input.output]]: input/output library <a id="diff.cpp11.input.output">[[diff.cpp11.input.output]]</a>
+**Change:** `gets` is not defined. **Rationale:** Use of `gets` is
+considered dangerous. **Effect on original feature:** Valid C++11 code
+that uses the `gets` function may fail to compile in this International
+Standard.

Diff to HTML by rtfpessoa