[dcl.init.ref] - C++20 → C++23

Files changed (1) hide show

tmp/tmpeqd1o0fw/{from.md → to.md} +30 -28

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

@@ -1,9 +1,9 @@
 ### References <a id="dcl.init.ref">[[dcl.init.ref]]</a>
-A variable whose declared type is “reference to type `T`” [[dcl.ref]]
-shall be initialized.
 [*Example 1*:
 ``` cpp
 int g(int) noexcept;
@@ -68,14 +68,14 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
     “*cv3* `T3`”, where “*cv1* `T1`” is reference-compatible with “*cv3*
     `T3`”[^7] (this conversion is selected by enumerating the applicable
     conversion functions [[over.match.ref]] and choosing the best one
     through overload resolution [[over.match]]),
-  then the reference is bound to the initializer expression lvalue in
- the first case and to the lvalue result of the conversion in the
- second case (or, in either case, to the appropriate base class
- subobject of the object).
   \[*Note 2*: The usual lvalue-to-rvalue [[conv.lval]], array-to-pointer
   [[conv.array]], and function-to-pointer [[conv.func]] standard
   conversions are not needed, and therefore are suppressed, when such
   direct bindings to lvalues are done. — *end note*]
   \[*Example 3*:
@@ -109,55 +109,57 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
   - has a class type (i.e., `T2` is a class type), where `T1` is not
     reference-related to `T2`, and can be converted to an rvalue or
     function lvalue of type “*cv3* `T3`”, where “*cv1* `T1`” is
     reference-compatible with “*cv3* `T3`” (see  [[over.match.ref]]),
-  then the value of the initializer expression in the first case and the
- result of the conversion in the second case is called the converted
- initializer. If the converted initializer is a prvalue, its type `T4`
- is adjusted to type “*cv1* `T4`” [[conv.qual]] and the temporary
- materialization conversion [[conv.rval]] is applied. In any case, the
- reference is bound to the resulting glvalue (or to an appropriate base
-  class subobject).
   \[*Example 5*:
   ``` cpp
   struct A { };
   struct B : A { } b;
   extern B f();
-  const A& rca2 = f();                // bound to the A subobject of the B rvalue.
   A&& rra = f();                      // same as above
   struct X {
     operator B();
     operator int&();
   } x;
-  const A& r = x;                     // bound to the A subobject of the result of the conversion
   int i2 = 42;
-  int&& rri = static_cast<int&&>(i2); // bound directly to i2
-  B&& rrb = x;                        // bound directly to the result of operator B
   ```
   — *end example*]
 - Otherwise:
   - If `T1` or `T2` is a class type and `T1` is not reference-related to
     `T2`, user-defined conversions are considered using the rules for
     copy-initialization of an object of type “*cv1* `T1`” by
-    user-defined conversion ([[dcl.init]], [[over.match.copy]],
-    [[over.match.conv]]); the program is ill-formed if the corresponding
- non-reference copy-initialization would be ill-formed. The result of
- the call to the conversion function, as described for the
-    non-reference copy-initialization, is then used to direct-initialize
-    the reference. For this direct-initialization, user-defined
-    conversions are not considered.
   - Otherwise, the initializer expression is implicitly converted to a
-    prvalue of type “*cv1* `T1`”. The temporary materialization
- conversion is applied and the reference is bound to the result.
   If `T1` is reference-related to `T2`:
   - *cv1* shall be the same cv-qualification as, or greater
     cv-qualification than, *cv2*; and
   - if the reference is an rvalue reference, the initializer expression
-    shall not be an lvalue.
   \[*Example 6*:
   ``` cpp
   struct Banana { };
   struct Enigma { operator const Banana(); };
@@ -188,8 +190,8 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
 In all cases except the last (i.e., implicitly converting the
 initializer expression to the referenced type), the reference is said to
 *bind directly* to the initializer expression.
-[*Note 3*:  [[class.temporary]] describes the lifetime of temporaries
 bound to references. — *end note*]

 ### References <a id="dcl.init.ref">[[dcl.init.ref]]</a>
+A variable whose declared type is “reference to `T`” [[dcl.ref]] shall
+be initialized.
 [*Example 1*:
 ``` cpp
 int g(int) noexcept;
     “*cv3* `T3`”, where “*cv1* `T1`” is reference-compatible with “*cv3*
     `T3`”[^7] (this conversion is selected by enumerating the applicable
     conversion functions [[over.match.ref]] and choosing the best one
     through overload resolution [[over.match]]),
+  then the reference binds to the initializer expression lvalue in the
+  first case and to the lvalue result of the conversion in the second
+  case (or, in either case, to the appropriate base class subobject of
+  the object).
   \[*Note 2*: The usual lvalue-to-rvalue [[conv.lval]], array-to-pointer
   [[conv.array]], and function-to-pointer [[conv.func]] standard
   conversions are not needed, and therefore are suppressed, when such
   direct bindings to lvalues are done. — *end note*]
   \[*Example 3*:
   - has a class type (i.e., `T2` is a class type), where `T1` is not
     reference-related to `T2`, and can be converted to an rvalue or
     function lvalue of type “*cv3* `T3`”, where “*cv1* `T1`” is
     reference-compatible with “*cv3* `T3`” (see  [[over.match.ref]]),
+  then the initializer expression in the first case and the converted
+ expression in the second case is called the converted initializer. If
+  the converted initializer is a prvalue, its type `T4` is adjusted to
+  type “*cv1* `T4`” [[conv.qual]] and the temporary materialization
+  conversion [[conv.rval]] is applied. In any case, the reference binds
+  to the resulting glvalue (or to an appropriate base class subobject).
   \[*Example 5*:
   ``` cpp
   struct A { };
   struct B : A { } b;
   extern B f();
+  const A& rca2 = f();                // binds to the A subobject of the B rvalue.
   A&& rra = f();                      // same as above
   struct X {
     operator B();
     operator int&();
   } x;
+  const A& r = x;                     // binds to the A subobject of the result of the conversion
   int i2 = 42;
+  int&& rri = static_cast<int&&>(i2); // binds directly to i2
+  B&& rrb = x;                        // binds directly to the result of operator B
   ```
   — *end example*]
 - Otherwise:
   - If `T1` or `T2` is a class type and `T1` is not reference-related to
     `T2`, user-defined conversions are considered using the rules for
     copy-initialization of an object of type “*cv1* `T1`” by
+    user-defined conversion
+    [[dcl.init]], [[over.match.copy]], [[over.match.conv]]; the program
+ is ill-formed if the corresponding non-reference copy-initialization
+ would be ill-formed. The result of the call to the conversion
+ function, as described for the non-reference copy-initialization, is
+ then used to direct-initialize the reference. For this
+ direct-initialization, user-defined conversions are not considered.
   - Otherwise, the initializer expression is implicitly converted to a
+    prvalue of type “`T1`”. The temporary materialization conversion is
+    applied, considering the type of the prvalue to be “*cv1* `T1`”, and
+    the reference is bound to the result.
   If `T1` is reference-related to `T2`:
   - *cv1* shall be the same cv-qualification as, or greater
     cv-qualification than, *cv2*; and
   - if the reference is an rvalue reference, the initializer expression
+    shall not be an lvalue. \[*Note 3*: This can be affected by whether
+    the initializer expression is move-eligible
+    [[expr.prim.id.unqual]]. — *end note*]
   \[*Example 6*:
   ``` cpp
   struct Banana { };
   struct Enigma { operator const Banana(); };
 In all cases except the last (i.e., implicitly converting the
 initializer expression to the referenced type), the reference is said to
 *bind directly* to the initializer expression.
+[*Note 4*:  [[class.temporary]] describes the lifetime of temporaries
 bound to references. — *end note*]

Diff to HTML by rtfpessoa