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

Files changed (1) hide show

tmp/tmp2o3rgo0x/{from.md → to.md} +37 -29

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

@@ -19,12 +19,12 @@ List-initialization can be used
 - as the initializer in a *new-expression* [[expr.new]]
 - in a `return` statement [[stmt.return]]
 - as a *for-range-initializer* [[stmt.iter]]
 - as a function argument [[expr.call]]
 - as a subscript [[expr.sub]]
-- as an argument to a constructor invocation ([[dcl.init]],
-  [[expr.type.conv]])
 - as an initializer for a non-static data member [[class.mem]]
 - in a *mem-initializer* [[class.base.init]]
 - on the right-hand side of an assignment [[expr.ass]]
 [*Example 1*:
@@ -56,12 +56,13 @@ initializer list as the argument to the constructor template
 `template<class T> C(T)` of a class `C` does not create an
 initializer-list constructor, because an initializer list argument
 causes the corresponding parameter to be a non-deduced context
 [[temp.deduct.call]]. — *end note*]
-The template `std::initializer_list` is not predefined; if the header
-`<initializer_list>` is not imported or included prior to a use of
 `std::initializer_list` — even an implicit use in which the type is not
 named [[dcl.spec.auto]] — the program is ill-formed.
 List-initialization of an object or reference of type `T` is defined as
 follows:
@@ -100,22 +101,22 @@ follows:
     int m1;
     double m2, m3;
   };
   S2 s21 = { 1, 2, 3.0 };             // OK
   S2 s22 { 1.0, 2, 3 };               // error: narrowing
-  S2 s23 { };                         // OK: default to 0,0,0
   ```
   — *end example*]
 - Otherwise, if the initializer list has no elements and `T` is a class
   type with a default constructor, the object is value-initialized.
 - Otherwise, if `T` is a specialization of `std::initializer_list<E>`,
   the object is constructed as described below.
 - Otherwise, if `T` is a class type, constructors are considered. The
   applicable constructors are enumerated and the best one is chosen
-  through overload resolution ([[over.match]], [[over.match.list]]). If
- a narrowing conversion (see below) is required to convert any of the
   arguments, the program is ill-formed.
   \[*Example 4*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
@@ -144,13 +145,13 @@ follows:
     // no initializer-list constructors
     S(int, double, double);           // #1
     S();                              // #2
     // ...
   };
-  S s1 = { 1, 2, 3.0 };               // OK: invoke #1
   S s2 { 1.0, 2, 3 };                 // error: narrowing
-  S s3 { };                           // OK: invoke #2
   ```
   — *end example*]
 - Otherwise, if `T` is an enumeration with a fixed underlying type
   [[dcl.enum]] `U`, the *initializer-list* has a single element `v`, `v`
@@ -191,32 +192,32 @@ follows:
   int x2 {2.0};                       // error: narrowing
   ```
   — *end example*]
 - Otherwise, if `T` is a reference type, a prvalue is generated. The
-  prvalue initializes its result object by copy-list-initialization. The
-  prvalue is then used to direct-initialize the reference. The type of
-  the temporary is the type referenced by `T`, unless `T` is “reference
-  to array of unknown bound of `U`”, in which case the type of the
- temporary is the type of `x` in the declaration `U x[] H`, where H is
-  the initializer list.
   \[*Note 3*: As usual, the binding will fail and the program is
   ill-formed if the reference type is an lvalue reference to a non-const
   type. — *end note*]
   \[*Example 9*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(const std::string&);            // #2
     // ...
   };
-  const S& r1 = { 1, 2, 3.0 };        // OK: invoke #1
-  const S& r2 { "Spinach" };          // OK: invoke #2
   S& r3 = { 1, 2, 3 };                // error: initializer is not an lvalue
   const int& i1 = { 1 };              // OK
   const int& i2 = { 1.1 };            // error: narrowing
-  const int (&iar)[2] = { 1, 2 };     // OK: iar is bound to temporary array
   struct A { } a;
   struct B { explicit B(const A&); };
   const B& b2{a};                     // error: cannot copy-list-initialize B temporary from A
   ```
@@ -335,27 +336,34 @@ variable, so the array persists for the lifetime of the variable. For
 member, so the program is ill-formed [[class.base.init]].
 — *end example*]
 [*Note 6*: The implementation is free to allocate the array in
-read-only memory if an explicit array with the same initializer could be
 so allocated. — *end note*]
 A *narrowing conversion* is an implicit conversion
 - from a floating-point type to an integer type, or
-- from `long double` to `double` or `float`, or from `double` to
- `float`, except where the source is a constant expression and the
   actual value after conversion is within the range of values that can
   be represented (even if it cannot be represented exactly), or
 - from an integer type or unscoped enumeration type to a floating-point
   type, except where the source is a constant expression and the actual
   value after conversion will fit into the target type and will produce
   the original value when converted back to the original type, or
 - from an integer type or unscoped enumeration type to an integer type
   that cannot represent all the values of the original type, except
-  where the source is a constant expression whose value after integral
     promotions will fit into the target type, or
 - from a pointer type or a pointer-to-member type to `bool`.
 [*Note 7*: As indicated above, such conversions are not allowed at the
 top level in list-initializations. — *end note*]
@@ -364,24 +372,24 @@ top level in list-initializations. — *end note*]
 ``` cpp
 int x = 999;                    // x is not a constant expression
 const int y = 999;
 const int z = 99;
-char c1 = x;                    // OK, though it might narrow (in this case, it does narrow)
-char c2{x};                     // error: might narrow
 char c3{y};                     // error: narrows (assuming char is 8 bits)
-char c4{z};                     // OK: no narrowing needed
-unsigned char uc1 = {5};        // OK: no narrowing needed
 unsigned char uc2 = {-1};       // error: narrows
 unsigned int ui1 = {-1};        // error: narrows
 signed int si1 =
   { (unsigned int)-1 };         // error: narrows
 int ii = {2.0};                 // error: narrows
-float f1 { x };                 // error: might narrow
-float f2 { 7 };                 // OK: 7 can be exactly represented as a float
 bool b = {"meow"};              // error: narrows
 int f(int);
-int a[] = { 2, f(2), f(2.0) };  // OK: the double-to-int conversion is not at the top level
 ```
 — *end example*]

 - as the initializer in a *new-expression* [[expr.new]]
 - in a `return` statement [[stmt.return]]
 - as a *for-range-initializer* [[stmt.iter]]
 - as a function argument [[expr.call]]
 - as a subscript [[expr.sub]]
+- as an argument to a constructor invocation
+  [[dcl.init]], [[expr.type.conv]]
 - as an initializer for a non-static data member [[class.mem]]
 - in a *mem-initializer* [[class.base.init]]
 - on the right-hand side of an assignment [[expr.ass]]
 [*Example 1*:
 `template<class T> C(T)` of a class `C` does not create an
 initializer-list constructor, because an initializer list argument
 causes the corresponding parameter to be a non-deduced context
 [[temp.deduct.call]]. — *end note*]
+The template `std::initializer_list` is not predefined; if a standard
+library declaration [[initializer.list.syn]], [[std.modules]] of
+`std::initializer_list` is not reachable from [[module.reach]] a use of
 `std::initializer_list` — even an implicit use in which the type is not
 named [[dcl.spec.auto]] — the program is ill-formed.
 List-initialization of an object or reference of type `T` is defined as
 follows:
     int m1;
     double m2, m3;
   };
   S2 s21 = { 1, 2, 3.0 };             // OK
   S2 s22 { 1.0, 2, 3 };               // error: narrowing
+  S2 s23 { };                         // OK, default to 0,0,0
   ```
   — *end example*]
 - Otherwise, if the initializer list has no elements and `T` is a class
   type with a default constructor, the object is value-initialized.
 - Otherwise, if `T` is a specialization of `std::initializer_list<E>`,
   the object is constructed as described below.
 - Otherwise, if `T` is a class type, constructors are considered. The
   applicable constructors are enumerated and the best one is chosen
+  through overload resolution [[over.match]], [[over.match.list]]. If a
+  narrowing conversion (see below) is required to convert any of the
   arguments, the program is ill-formed.
   \[*Example 4*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     // no initializer-list constructors
     S(int, double, double);           // #1
     S();                              // #2
     // ...
   };
+  S s1 = { 1, 2, 3.0 };               // OK, invoke #1
   S s2 { 1.0, 2, 3 };                 // error: narrowing
+  S s3 { };                           // OK, invoke #2
   ```
   — *end example*]
 - Otherwise, if `T` is an enumeration with a fixed underlying type
   [[dcl.enum]] `U`, the *initializer-list* has a single element `v`, `v`
   int x2 {2.0};                       // error: narrowing
   ```
   — *end example*]
 - Otherwise, if `T` is a reference type, a prvalue is generated. The
+  prvalue initializes its result object by copy-list-initialization from
+ the initializer list. The prvalue is then used to direct-initialize
+  the reference. The type of the prvalue is the type referenced by `T`,
+ unless `T` is “reference to array of unknown bound of `U`”, in which
+ case the type of the prvalue is the type of `x` in the declaration
+ `U x[] H`, where H is the initializer list.
   \[*Note 3*: As usual, the binding will fail and the program is
   ill-formed if the reference type is an lvalue reference to a non-const
   type. — *end note*]
   \[*Example 9*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(const std::string&);            // #2
     // ...
   };
+  const S& r1 = { 1, 2, 3.0 };        // OK, invoke #1
+  const S& r2 { "Spinach" };          // OK, invoke #2
   S& r3 = { 1, 2, 3 };                // error: initializer is not an lvalue
   const int& i1 = { 1 };              // OK
   const int& i2 = { 1.1 };            // error: narrowing
+  const int (&iar)[2] = { 1, 2 };     // OK, iar is bound to temporary array
   struct A { } a;
   struct B { explicit B(const A&); };
   const B& b2{a};                     // error: cannot copy-list-initialize B temporary from A
   ```
 member, so the program is ill-formed [[class.base.init]].
 — *end example*]
 [*Note 6*: The implementation is free to allocate the array in
+read-only memory if an explicit array with the same initializer can be
 so allocated. — *end note*]
 A *narrowing conversion* is an implicit conversion
 - from a floating-point type to an integer type, or
+- from a floating-point type `T` to another floating-point type whose
+ floating-point conversion rank is neither greater than nor equal to
+  that of `T`, except where the source is a constant expression and the
   actual value after conversion is within the range of values that can
   be represented (even if it cannot be represented exactly), or
 - from an integer type or unscoped enumeration type to a floating-point
   type, except where the source is a constant expression and the actual
   value after conversion will fit into the target type and will produce
   the original value when converted back to the original type, or
 - from an integer type or unscoped enumeration type to an integer type
   that cannot represent all the values of the original type, except
+  where
+  - the source is a bit-field whose width w is less than that of its
+    type (or, for an enumeration type, its underlying type) and the
+    target type can represent all the values of a hypothetical extended
+    integer type with width w and with the same signedness as the
+    original type or
+  - the source is a constant expression whose value after integral
     promotions will fit into the target type, or
 - from a pointer type or a pointer-to-member type to `bool`.
 [*Note 7*: As indicated above, such conversions are not allowed at the
 top level in list-initializations. — *end note*]
 ``` cpp
 int x = 999;                    // x is not a constant expression
 const int y = 999;
 const int z = 99;
+char c1 = x;                    // OK, though it potentially narrows (in this case, it does narrow)
+char c2{x};                     // error: potentially narrows
 char c3{y};                     // error: narrows (assuming char is 8 bits)
+char c4{z};                     // OK, no narrowing needed
+unsigned char uc1 = {5};        // OK, no narrowing needed
 unsigned char uc2 = {-1};       // error: narrows
 unsigned int ui1 = {-1};        // error: narrows
 signed int si1 =
   { (unsigned int)-1 };         // error: narrows
 int ii = {2.0};                 // error: narrows
+float f1 { x };                 // error: potentially narrows
+float f2 { 7 };                 // OK, 7 can be exactly represented as a float
 bool b = {"meow"};              // error: narrows
 int f(int);
+int a[] = { 2, f(2), f(2.0) };  // OK, the double-to-int conversion is not at the top level
 ```
 — *end example*]

Diff to HTML by rtfpessoa