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

Files changed (1) hide show

tmp/tmp4hbs9hqa/{from.md → to.md} +34 -31

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

@@ -1,58 +1,60 @@
 ## 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; }
@@ -62,42 +64,43 @@ int f(bool cond) {
   (cond ? s : throw 0).mf();
   return s.x;
 }
 ```
-In C++11, `f(true)` returns `1`. In this International Standard, it
-returns `2`.
 ``` cpp
 sizeof(true ? "" : throw 0)
 ```
-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;
 };
@@ -105,22 +108,22 @@ 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.

 ## C++ and ISO C++11 <a id="diff.cpp11">[[diff.cpp11]]</a>
+### General <a id="diff.cpp11.general">[[diff.cpp11.general]]</a>
+Subclause [[diff.cpp11]] 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 revision of C++. For example, the following
+code is valid both in C++11 and in this revision of C++, 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 revision of C++. For example:
 ``` 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 revision of C++{}
 ```
 ###  [[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 can 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 revision of C++, 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 revision of
+C++. For example:
 ``` cpp
 struct S {
   int x = 1;
   void mf() { x = 2; }
   (cond ? s : throw 0).mf();
   return s.x;
 }
 ```
+In C++11, `f(true)` returns `1`. In this revision of C++, it returns
+`2`.
 ``` cpp
 sizeof(true ? "" : throw 0)
 ```
+In C++11, the expression yields `sizeof(const char*)`. In this revision
+of C++, 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 revision of C++. For
+example:
 ``` cpp
 struct S {
   constexpr const int &f();
   int &f();
 };
 ```
+This code is valid in C++11 but invalid in this revision of C++ because
+it declares the same member function twice with different return types.
 **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 revision of C++.
+For example:
 ``` cpp
 struct S {          // Aggregate in C++14{} onwards.
   int m = 1;
 };
   operator int();
   operator S();
 };
 X a{};
 S b{a};             // uses copy constructor in C++11{},
+                    // performs aggregate initialization in this revision of C++{}
 ```
 ###  [[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
+revision of C++.
 ###  [[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 revision of
+C++.

Diff to HTML by rtfpessoa