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

Files changed (1) hide show

tmp/tmpis30l8kp/{from.md → to.md} +49 -57

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

@@ -1,8 +1,8 @@
 ### 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
@@ -25,19 +25,19 @@ void f() {
 A reference cannot be changed to refer to another object after
 initialization.
 [*Note 1*: Assignment to a reference assigns to the object referred to
-by the reference ([[expr.ass]]). — *end note*]
-Argument passing ([[expr.call]]) and function value return (
-[[stmt.return]]) are initializations.
 The initializer can be omitted for a reference only in a parameter
-declaration ([[dcl.fct]]), in the declaration of a function return
-type, in the declaration of a class member within its class definition (
-[[class.mem]]), and where the `extern` specifier is explicitly used.
 [*Example 2*:
 ``` cpp
 int& r1;                        // error: initializer missing
@@ -45,48 +45,41 @@ extern int& r2;                 // OK
 ```
 — *end example*]
 Given types “*cv1* `T1`” and “*cv2* `T2`”, “*cv1* `T1`” is
-*reference-related* to “*cv2* `T2`” if `T1` is the same type as `T2`, or
-`T1` is a base class of `T2`. “*cv1* `T1`” is *reference-compatible*
-with “*cv2* `T2`” if
-- `T1` is reference-related to `T2`, or
-- `T2` is “`noexcept` function” and `T1` is “function”, where the
-  function types are otherwise the same,
-and *cv1* is the same cv-qualification as, or greater cv-qualification
-than, *cv2*. In all cases where the reference-related or
 reference-compatible relationship of two types is used to establish the
-validity of a reference binding, and `T1` is a base class of `T2`, a
-program that necessitates such a binding is ill-formed if `T1` is an
-inaccessible (Clause  [[class.access]]) or ambiguous (
-[[class.member.lookup]]) base class of `T2`.
 A reference to type “*cv1* `T1`” is initialized by an expression of type
 “*cv2* `T2`” as follows:
 - If the reference is an lvalue reference and the initializer expression
   - is an lvalue (but is not a bit-field), and “*cv1* `T1`” is
     reference-compatible with “*cv2* `T2`”, or
   - 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 lvalue of type
     “*cv3* `T3`”, where “*cv1* `T1`” is reference-compatible with “*cv3*
-    `T3`”[^14] (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*:
   ``` cpp
   double d = 2.0;
   double& rd = d;                 // rd refers to d
   const double& rcd = d;          // rcd refers to d
@@ -97,36 +90,36 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
   const A& rca = b;               // rca refers to A subobject in b
   int& ir = B();                  // ir refers to the result of B::operator int&
   ```
   — *end example*]
-- Otherwise, the reference shall be an lvalue reference to a
- non-volatile const type (i.e., *cv1* shall be `const`), or the
- reference shall be an rvalue reference.
   \[*Example 4*:
   ``` cpp
   double& rd2 = 2.0;              // error: not an lvalue and reference not const
   int  i = 2;
   double& rd3 = i;                // error: type mismatch and reference not const
   ```
   — *end example*]
- - If the initializer expression
   - is an rvalue (but not a bit-field) or function lvalue and “*cv1*
     `T1`” is reference-compatible with “*cv2* `T2`”, or
   - 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();
@@ -142,41 +135,40 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
   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(); };
   struct Alaska { operator Banana&(); };
   void enigmatic() {
     typedef const Banana ConstBanana;
- Banana &&banana1 = ConstBanana(); // ill-formed
- Banana &&banana2 = Enigma();      // ill-formed
- Banana &&banana3 = Alaska();      // ill-formed
   }
   const double& rcd2 = 2;             // rcd2 refers to temporary with value 2.0
   double&& rrd = 2;                   // rrd refers to temporary with value 2.0
   const volatile int cvi = 1;
@@ -193,11 +185,11 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
   ```
   — *end example*]
 In all cases except the last (i.e., implicitly converting the
-initializer expression to the underlying type of the reference), 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 type `T`” [[dcl.ref]]
 shall be initialized.
 [*Example 1*:
 ``` cpp
 A reference cannot be changed to refer to another object after
 initialization.
 [*Note 1*: Assignment to a reference assigns to the object referred to
+by the reference [[expr.ass]]. — *end note*]
+Argument passing [[expr.call]] and function value return [[stmt.return]]
+are initializations.
 The initializer can be omitted for a reference only in a parameter
+declaration [[dcl.fct]], in the declaration of a function return type,
+in the declaration of a class member within its class definition
+[[class.mem]], and where the `extern` specifier is explicitly used.
 [*Example 2*:
 ``` cpp
 int& r1;                        // error: initializer missing
 ```
 — *end example*]
 Given types “*cv1* `T1`” and “*cv2* `T2`”, “*cv1* `T1`” is
+*reference-related* to “*cv2* `T2`” if `T1` is similar [[conv.qual]] to
+`T2`, or `T1` is a base class of `T2`. “*cv1* `T1`” is
+*reference-compatible* with “*cv2* `T2`” if a prvalue of type “pointer
+to *cv2* `T2`” can be converted to the type “pointer to *cv1* `T1`” via
+a standard conversion sequence [[conv]]. In all cases where the
 reference-compatible relationship of two types is used to establish the
+validity of a reference binding and the standard conversion sequence
+would be ill-formed, a program that necessitates such a binding is
+ill-formed.
 A reference to type “*cv1* `T1`” is initialized by an expression of type
 “*cv2* `T2`” as follows:
 - If the reference is an lvalue reference and the initializer expression
   - is an lvalue (but is not a bit-field), and “*cv1* `T1`” is
     reference-compatible with “*cv2* `T2`”, or
   - 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 lvalue 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*:
   ``` cpp
   double d = 2.0;
   double& rd = d;                 // rd refers to d
   const double& rcd = d;          // rcd refers to d
   const A& rca = b;               // rca refers to A subobject in b
   int& ir = B();                  // ir refers to the result of B::operator int&
   ```
   — *end example*]
+- Otherwise, if the reference is an lvalue reference to a type that is
+ not const-qualified or is volatile-qualified, the program is
+ ill-formed.
   \[*Example 4*:
   ``` cpp
   double& rd2 = 2.0;              // error: not an lvalue and reference not const
   int  i = 2;
   double& rd3 = i;                // error: type mismatch and reference not const
   ```
   — *end example*]
+- Otherwise, if the initializer expression
   - is an rvalue (but not a bit-field) or function lvalue and “*cv1*
     `T1`” is reference-compatible with “*cv2* `T2`”, or
   - 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();
   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(); };
   struct Alaska { operator Banana&(); };
   void enigmatic() {
     typedef const Banana ConstBanana;
+ Banana &&banana1 = ConstBanana(); // error
+ Banana &&banana2 = Enigma();      // error
+ Banana &&banana3 = Alaska();      // error
   }
   const double& rcd2 = 2;             // rcd2 refers to temporary with value 2.0
   double&& rrd = 2;                   // rrd refers to temporary with value 2.0
   const volatile int cvi = 1;
   ```
   — *end example*]
 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*]

Diff to HTML by rtfpessoa