[conv] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp15hv_lu4/{from.md → to.md} +73 -53

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

@@ -19,11 +19,12 @@ following order:
 [*Note 1*: A standard conversion sequence can be empty, i.e., it can
 consist of no conversions. — *end note*]
 A standard conversion sequence will be applied to an expression if
-necessary to convert it to a required destination type.
 [*Note 2*:
 Expressions with a given type will be implicitly converted to other
 types in several contexts:
@@ -41,12 +42,12 @@ types in several contexts:
   [[dcl.init.ref]].
 — *end note*]
 An expression E can be *implicitly converted* to a type `T` if and only
-if the declaration `T t=E;` is well-formed, for some invented temporary
-variable `t` [[dcl.init]].
 Certain language constructs require that an expression be converted to a
 Boolean value. An expression E appearing in such a context is said to be
 *contextually converted to `bool`* and is well-formed if and only if the
 declaration `bool t(E);` is well-formed, for some invented temporary
@@ -126,15 +127,30 @@ rules:
   `T` is volatile-qualified [[intro.execution]], and the glvalue can
   refer to an inactive member of a union [[class.union]]. — *end note*]
 - Otherwise, if `T` has a class type, the conversion copy-initializes
   the result object from the glvalue.
 - Otherwise, if the object to which the glvalue refers contains an
-  invalid pointer value [[basic.stc.dynamic.deallocation]], the behavior
- is *implementation-defined*.
 - Otherwise, the object indicated by the glvalue is read
-  [[defns.access]], and the value contained in the object is the prvalue
-  result.
 [*Note 2*: See also  [[basic.lval]]. — *end note*]
 ### Array-to-pointer conversion <a id="conv.array">[[conv.array]]</a>
@@ -183,14 +199,10 @@ element type are also taken as the cv-qualifiers cvᵢ of the array.
 [*Example 1*: The type denoted by the *type-id* `const int **` has
 three qualification-decompositions, taking `U` as “`int`”, as “pointer
 to `const int`”, and as “pointer to pointer to
 `const int`”. — *end example*]
-The n-tuple of cv-qualifiers after the first one in the longest
-qualification-decomposition of `T`, that is, cv₁, cv₂, …, cvₙ, is called
-the *cv-qualification signature* of `T`.
 Two types `T1` and `T2` are *similar* if they have
 qualification-decompositions with the same n such that corresponding Pᵢ
 components are either the same or one is “array of Nᵢ” and the other is
 “array of unknown bound of”, and the types denoted by `U` are the same.
@@ -242,24 +254,20 @@ than “*cv1* `T`”. — *end note*]
 pointer-to-member-function types) are never cv-qualified
 [[dcl.fct]]. — *end note*]
 ### Integral promotions <a id="conv.prom">[[conv.prom]]</a>
-A prvalue of an integer type other than `bool`, `char8_t`, `char16_t`,
-`char32_t`, or `wchar_t` whose integer conversion rank [[conv.rank]] is
-less than the rank of `int` can be converted to a prvalue of type `int`
-if `int` can represent all the values of the source type; otherwise, the
-source prvalue can be converted to a prvalue of type `unsigned int`.
-A prvalue of type `char8_t`, `char16_t`, `char32_t`, or `wchar_t`
-[[basic.fundamental]] can be converted to a prvalue of the first of the
-following types that can represent all the values of its underlying
-type: `int`, `unsigned int`, `long int`, `unsigned long int`,
-`long long int`, or `unsigned long long int`. If none of the types in
-that list can represent all the values of its underlying type, a prvalue
-of type `char8_t`, `char16_t`, `char32_t`, or `wchar_t` can be converted
-to a prvalue of its underlying type.
 A prvalue of an unscoped enumeration type whose underlying type is not
 fixed can be converted to a prvalue of the first of the following types
 that can represent all the values of the enumeration [[dcl.enum]]:
 `int`, `unsigned int`, `long int`, `unsigned long int`, `long long int`,
@@ -275,17 +283,25 @@ A prvalue of an unscoped enumeration type whose underlying type is fixed
 [[dcl.enum]] can be converted to a prvalue of its underlying type.
 Moreover, if integral promotion can be applied to its underlying type, a
 prvalue of an unscoped enumeration type whose underlying type is fixed
 can also be converted to a prvalue of the promoted underlying type.
-A prvalue for an integral bit-field [[class.bit]] can be converted to a
-prvalue of type `int` if `int` can represent all the values of the
-bit-field; otherwise, it can be converted to `unsigned int` if
-`unsigned int` can represent all the values of the bit-field. If the
-bit-field is larger yet, no integral promotion applies to it. If the
-bit-field has enumeration type, it is treated as any other value of that
-type for promotion purposes.
 A prvalue of type `bool` can be converted to a prvalue of type `int`,
 with `false` becoming zero and `true` becoming one.
 These conversions are called *integral promotions*.
@@ -361,60 +377,64 @@ to one.
 A *null pointer constant* is an integer literal [[lex.icon]] with value
 zero or a prvalue of type `std::nullptr_t`. A null pointer constant can
 be converted to a pointer type; the result is the null pointer value of
 that type [[basic.compound]] and is distinguishable from every other
 value of object pointer or function pointer type. Such a conversion is
-called a *null pointer conversion*. Two null pointer values of the same
-type shall compare equal. The conversion of a null pointer constant to a
-pointer to cv-qualified type is a single conversion, and not the
-sequence of a pointer conversion followed by a qualification conversion
-[[conv.qual]]. A null pointer constant of integral type can be converted
-to a prvalue of type `std::nullptr_t`.
 [*Note 1*: The resulting prvalue is not a null pointer
 value. — *end note*]
 A prvalue of type “pointer to cv `T`”, where `T` is an object type, can
 be converted to a prvalue of type “pointer to cv `void`”. The pointer
 value [[basic.compound]] is unchanged by this conversion.
-A prvalue of type “pointer to cv `D`”, where `D` is a complete class
 type, can be converted to a prvalue of type “pointer to cv `B`”, where
 `B` is a base class [[class.derived]] of `D`. If `B` is an inaccessible
 [[class.access]] or ambiguous [[class.member.lookup]] base class of `D`,
-a program that necessitates this conversion is ill-formed. The result of
-the conversion is a pointer to the base class subobject of the derived
-class object. The null pointer value is converted to the null pointer
-value of the destination type.
 ### Pointer-to-member conversions <a id="conv.mem">[[conv.mem]]</a>
 A null pointer constant [[conv.ptr]] can be converted to a
 pointer-to-member type; the result is the *null member pointer value* of
 that type and is distinguishable from any pointer to member not created
 from a null pointer constant. Such a conversion is called a *null member
-pointer conversion*. Two null member pointer values of the same type
-shall compare equal. The conversion of a null pointer constant to a
 pointer to member of cv-qualified type is a single conversion, and not
 the sequence of a pointer-to-member conversion followed by a
 qualification conversion [[conv.qual]].
 A prvalue of type “pointer to member of `B` of type cv `T`”, where `B`
 is a class type, can be converted to a prvalue of type “pointer to
 member of `D` of type cv `T`”, where `D` is a complete class derived
 [[class.derived]] from `B`. If `B` is an inaccessible [[class.access]],
 ambiguous [[class.member.lookup]], or virtual [[class.mi]] base class of
 `D`, or a base class of a virtual base class of `D`, a program that
-necessitates this conversion is ill-formed. The result of the conversion
-refers to the same member as the pointer to member before the conversion
-took place, but it refers to the base class member as if it were a
-member of the derived class. The result refers to the member in `D`’s
-instance of `B`. Since the result has type “pointer to member of `D` of
-type cv `T`”, indirection through it with a `D` object is valid. The
-result is the same as if indirecting through the pointer to member of
-`B` with the `B` subobject of `D`. The null member pointer value is
-converted to the null member pointer value of the destination type.[^8]
 ### Function pointer conversions <a id="conv.fctptr">[[conv.fctptr]]</a>
 A prvalue of type “pointer to `noexcept` function” can be converted to a
 prvalue of type “pointer to function”. The result is a pointer to the

 [*Note 1*: A standard conversion sequence can be empty, i.e., it can
 consist of no conversions. — *end note*]
 A standard conversion sequence will be applied to an expression if
+necessary to convert it to an expression having a required destination
+type and value category.
 [*Note 2*:
 Expressions with a given type will be implicitly converted to other
 types in several contexts:
   [[dcl.init.ref]].
 — *end note*]
 An expression E can be *implicitly converted* to a type `T` if and only
+if the declaration `T t = E;` is well-formed, for some invented
+temporary variable `t` [[dcl.init]].
 Certain language constructs require that an expression be converted to a
 Boolean value. An expression E appearing in such a context is said to be
 *contextually converted to `bool`* and is well-formed if and only if the
 declaration `bool t(E);` is well-formed, for some invented temporary
   `T` is volatile-qualified [[intro.execution]], and the glvalue can
   refer to an inactive member of a union [[class.union]]. — *end note*]
 - Otherwise, if `T` has a class type, the conversion copy-initializes
   the result object from the glvalue.
 - Otherwise, if the object to which the glvalue refers contains an
+  invalid pointer value [[basic.compound]], the behavior is
+  *implementation-defined*.
+- Otherwise, if the bits in the value representation of the object to
+  which the glvalue refers are not valid for the object’s type, the
+  behavior is undefined.
+  \[*Example 2*:
+  ``` cpp
+  bool f() {
+    bool b = true;
+    char c = 42;
+    memcpy(&b, &c, 1);
+    return b;         // undefined behavior if 42 is not a valid value representation for bool
+  }
+  ```
+  — *end example*]
 - Otherwise, the object indicated by the glvalue is read
+  [[defns.access]]. Let `V` be the value contained in the object. If `T`
+ is an integer type, the prvalue result is the value of type `T`
+  congruent [[basic.fundamental]] to `V`, and `V` otherwise.
 [*Note 2*: See also  [[basic.lval]]. — *end note*]
 ### Array-to-pointer conversion <a id="conv.array">[[conv.array]]</a>
 [*Example 1*: The type denoted by the *type-id* `const int **` has
 three qualification-decompositions, taking `U` as “`int`”, as “pointer
 to `const int`”, and as “pointer to pointer to
 `const int`”. — *end example*]
 Two types `T1` and `T2` are *similar* if they have
 qualification-decompositions with the same n such that corresponding Pᵢ
 components are either the same or one is “array of Nᵢ” and the other is
 “array of unknown bound of”, and the types denoted by `U` are the same.
 pointer-to-member-function types) are never cv-qualified
 [[dcl.fct]]. — *end note*]
 ### Integral promotions <a id="conv.prom">[[conv.prom]]</a>
+For the purposes of [[conv.prom]], a *converted bit-field* is a prvalue
+that is the result of an lvalue-to-rvalue conversion [[conv.lval]]
+applied to a bit-field [[class.bit]].
+A prvalue that is not a converted bit-field and has an integer type
+other than `bool`, `char8_t`, `char16_t`, `char32_t`, or `wchar_t` whose
+integer conversion rank [[conv.rank]] is less than the rank of `int` can
+be converted to a prvalue of type `int` if `int` can represent all the
+values of the source type; otherwise, the source prvalue can be
+converted to a prvalue of type `unsigned int`.
 A prvalue of an unscoped enumeration type whose underlying type is not
 fixed can be converted to a prvalue of the first of the following types
 that can represent all the values of the enumeration [[dcl.enum]]:
 `int`, `unsigned int`, `long int`, `unsigned long int`, `long long int`,
 [[dcl.enum]] can be converted to a prvalue of its underlying type.
 Moreover, if integral promotion can be applied to its underlying type, a
 prvalue of an unscoped enumeration type whose underlying type is fixed
 can also be converted to a prvalue of the promoted underlying type.
+[*Note 1*: A converted bit-field of enumeration type is treated as any
+other value of that type for promotion purposes. — *end note*]
+A converted bit-field of integral type can be converted to a prvalue of
+type `int` if `int` can represent all the values of the bit-field;
+otherwise, it can be converted to `unsigned int` if `unsigned int` can
+represent all the values of the bit-field.
+A prvalue of type `char8_t`, `char16_t`, `char32_t`, or `wchar_t`
+[[basic.fundamental]] (including a converted bit-field that was not
+already promoted to `int` or `unsigned int` according to the rules
+above) can be converted to a prvalue of the first of the following types
+that can represent all the values of its underlying type: `int`,
+`unsigned int`, `long int`, `unsigned long int`, `long long int`,
+`unsigned long long int`, or its underlying type.
 A prvalue of type `bool` can be converted to a prvalue of type `int`,
 with `false` becoming zero and `true` becoming one.
 These conversions are called *integral promotions*.
 A *null pointer constant* is an integer literal [[lex.icon]] with value
 zero or a prvalue of type `std::nullptr_t`. A null pointer constant can
 be converted to a pointer type; the result is the null pointer value of
 that type [[basic.compound]] and is distinguishable from every other
 value of object pointer or function pointer type. Such a conversion is
+called a *null pointer conversion*. The conversion of a null pointer
+constant to a pointer to cv-qualified type is a single conversion, and
+not the sequence of a pointer conversion followed by a qualification
+conversion [[conv.qual]]. A null pointer constant of integral type can
+be converted to a prvalue of type `std::nullptr_t`.
 [*Note 1*: The resulting prvalue is not a null pointer
 value. — *end note*]
 A prvalue of type “pointer to cv `T`”, where `T` is an object type, can
 be converted to a prvalue of type “pointer to cv `void`”. The pointer
 value [[basic.compound]] is unchanged by this conversion.
+A prvalue `v` of type “pointer to cv `D`”, where `D` is a complete class
 type, can be converted to a prvalue of type “pointer to cv `B`”, where
 `B` is a base class [[class.derived]] of `D`. If `B` is an inaccessible
 [[class.access]] or ambiguous [[class.member.lookup]] base class of `D`,
+a program that necessitates this conversion is ill-formed. If `v` is a
+null pointer value, the result is a null pointer value. Otherwise, if
+`B` is a virtual base class of `D` and `v` does not point to an object
+whose type is similar [[conv.qual]] to `D` and that is within its
+lifetime or within its period of construction or destruction
+[[class.cdtor]], the behavior is undefined. Otherwise, the result is a
+pointer to the base class subobject of the derived class object.
 ### Pointer-to-member conversions <a id="conv.mem">[[conv.mem]]</a>
 A null pointer constant [[conv.ptr]] can be converted to a
 pointer-to-member type; the result is the *null member pointer value* of
 that type and is distinguishable from any pointer to member not created
 from a null pointer constant. Such a conversion is called a *null member
+pointer conversion*. The conversion of a null pointer constant to a
 pointer to member of cv-qualified type is a single conversion, and not
 the sequence of a pointer-to-member conversion followed by a
 qualification conversion [[conv.qual]].
 A prvalue of type “pointer to member of `B` of type cv `T`”, where `B`
 is a class type, can be converted to a prvalue of type “pointer to
 member of `D` of type cv `T`”, where `D` is a complete class derived
 [[class.derived]] from `B`. If `B` is an inaccessible [[class.access]],
 ambiguous [[class.member.lookup]], or virtual [[class.mi]] base class of
 `D`, or a base class of a virtual base class of `D`, a program that
+necessitates this conversion is ill-formed. If class `D` does not
+contain the original member and is not a base class of the class
+containing the original member, the behavior is undefined. Otherwise,
+the result of the conversion refers to the same member as the pointer to
+member before the conversion took place, but it refers to the base class
+member as if it were a member of the derived class. The result refers to
+the member in `D`’s instance of `B`. Since the result has type “pointer
+to member of `D` of type cv `T`”, indirection through it with a `D`
+object is valid. The result is the same as if indirecting through the
+pointer to member of `B` with the `B` subobject of `D`. The null member
+pointer value is converted to the null member pointer value of the
+destination type.[^8]
 ### Function pointer conversions <a id="conv.fctptr">[[conv.fctptr]]</a>
 A prvalue of type “pointer to `noexcept` function” can be converted to a
 prvalue of type “pointer to function”. The result is a pointer to the

Diff to HTML by rtfpessoa