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

Files changed (1) hide show

tmp/tmpp_1x62fm/{from.md → to.md} +92 -58

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

@@ -1,13 +1,14 @@
 ### References <a id="dcl.init.ref">[[dcl.init.ref]]</a>
-A variable declared to be a `T&` or `T&&`, that is, “reference to type
-`T`” ([[dcl.ref]]), shall be initialized by an object, or function, of
-type `T` or by an object that can be converted into a `T`.
 ``` cpp
-int g(int);
 void f() {
   int i;
   int& r = i;                   // r refers to i
   r = 1;                        // the value of i becomes 1
   int* p = &r;                  // p points to i
@@ -18,56 +19,75 @@ void f() {
   int (&ra)[3] = a;             // ra refers to the array a
   ra[1] = i;                    // modifies a[1]
 }
 ```
 A reference cannot be changed to refer to another object after
-initialization. Note that initialization of a reference is treated very
-differently from assignment to it. 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.
 ``` cpp
 int& r1;                        // error: initializer missing
 extern int& r2;                 // OK
 ```
-Given types “ `T1`” and “ `T2`,” “ `T1`” is to “ `T2`” if `T1` is the
-same type as `T2`, or `T1` is a base class of `T2`. “ `T1`” is with “
-`T2`” if `T1` is reference-related to `T2` 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 “ `T1`” is
-    reference-compatible with “ `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
-    “ `T3`,” where “ `T1`” is reference-compatible with “ `T3`”[^16]
-    (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). 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.
   ``` cpp
   double d = 2.0;
   double& rd = d;                 // rd refers to d
   const double& rcd = d;          // rcd refers to d
@@ -75,36 +95,39 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
   struct B : A { operator int&(); } b;
   A& ra = b;                      // ra refers to A subobject in b
   const A& rca = b;               // rca refers to A subobject in b
   int& ir = B();                  // ir refers to the result of B::operator int&
   ```
 - 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.
   ``` 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
   ```
   - If the initializer expression
-    - is an xvalue (but not a bit-field), class prvalue, array prvalue
- 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 xvalue,
- class prvalue, or function lvalue of type “*cv3* `T3`”, where
- “*cv1* `T1`” is reference-compatible with “*cv3* `T3`” (see
-      [[over.match.ref]]),
-    then the reference is bound to the value of the initializer
- expression in the first case and to the result of the conversion in
- the second case (or, in either case, to an appropriate base class
- subobject). In the second case, if the reference is an rvalue
- reference and the second standard conversion sequence of the
- user-defined conversion sequence includes an lvalue-to-rvalue
- conversion, the program is ill-formed.
     ``` cpp
     struct A { };
     struct B : A { } b;
     extern B f();
     const A& rca2 = f();                // bound to the A subobject of the B rvalue.
@@ -115,55 +138,66 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
     } 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
-    int&& rri2 = X();                   // error: lvalue-to-rvalue conversion applied to the
-                                        // result of operator int&
     ```
   - Otherwise:
-    - If `T1` is a class type, user-defined conversions are considered
- using the rules for copy-initialization of an object of type “
-      `T1`” by user-defined conversion ([[dcl.init]],
-      [[over.match.copy]]); 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. The program is ill-formed if
- the direct-initialization does not result in a direct binding or
- if it involves a user-defined conversion.
-    - If `T1` is a non-class type, a temporary of type “ `T1`” is
- created and copy-initialized ([[dcl.init]]) from the initializer
- expression. The reference is then bound to the temporary.
     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.
     ``` cpp
     struct Banana { };
     struct Enigma { operator const Banana(); };
     void enigmatic() {
       typedef const Banana ConstBanana;
       Banana &&banana1 = ConstBanana(); // ill-formed
       Banana &&banana2 = Enigma();      // 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;
-    const int& r2 = cvi;            // error: type qualifiers dropped
     double d2 = 1.0;
-    double&& rrd2 = d2;             // error: copying lvalue of related type
     int i3 = 2;
     double&& rrd3 = i3;             // rrd3 refers to temporary with value 2.0
     ```
-In all cases except the last (i.e., creating and initializing a
-temporary from the initializer expression), the reference is said to
-*bind directly* to the initializer expression.
-[[class.temporary]] describes the lifetime of temporaries bound to
-references.

 ### 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;
 void f() {
   int i;
   int& r = i;                   // r refers to i
   r = 1;                        // the value of i becomes 1
   int* p = &r;                  // p points to i
   int (&ra)[3] = a;             // ra refers to the array a
   ra[1] = i;                    // modifies a[1]
 }
 ```
+— *end example*]
 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
 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
   struct B : A { operator int&(); } b;
   A& ra = b;                      // ra refers to A subobject in b
   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();
     const A& rca2 = f();                // bound to the A subobject of the B rvalue.
     } 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(); };
+    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;
+    const int& r2 = cvi;            // error: cv-qualifier dropped
+    struct A { operator volatile int&(); } a;
+    const int& r3 = a;              // error: cv-qualifier dropped
+                                    // from result of conversion function
     double d2 = 1.0;
+    double&& rrd2 = d2;             // error: initializer is lvalue of related type
+    struct X { operator int&(); };
+    int&& rri2 = X();               // error: result of conversion function is lvalue of related type
     int i3 = 2;
     double&& rrd3 = i3;             // rrd3 refers to temporary with value 2.0
     ```
+    — *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*]

Diff to HTML by rtfpessoa