[conv] - C++20 → C++23

Files changed (1) hide show

tmp/tmp7916_luy/{from.md → to.md} +49 -43

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

@@ -1,7 +1,9 @@
 ## Standard conversions <a id="conv">[[conv]]</a>
 Standard conversions are implicit conversions with built-in meaning.
 [[conv]] enumerates the full set of such conversions. A *standard
 conversion sequence* is a sequence of standard conversions in the
 following order:
@@ -80,14 +82,16 @@ the operand of the unary `&` operator. Specific exceptions are given in
 the descriptions of those operators and contexts. — *end note*]
 ### Lvalue-to-rvalue conversion <a id="conv.lval">[[conv.lval]]</a>
 A glvalue [[basic.lval]] of a non-function, non-array type `T` can be
-converted to a prvalue.[^5] If `T` is an incomplete type, a program that
-necessitates this conversion is ill-formed. If `T` is a non-class type,
-the type of the prvalue is the cv-unqualified version of `T`. Otherwise,
-the type of the prvalue is `T`. [^6]
 When an lvalue-to-rvalue conversion is applied to an expression E, and
 either
 - E is not potentially evaluated, or
@@ -122,13 +126,12 @@ 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]],
- [[basic.stc.dynamic.safety]]), 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*]
@@ -166,46 +169,46 @@ int k = X().n;      // OK, X() prvalue is converted to xvalue
 — *end example*]
 ### Qualification conversions <a id="conv.qual">[[conv.qual]]</a>
-A *cv-decomposition* of a type `T` is a sequence of cvᵢ and Pᵢ such that
-`T` is
 where each cvᵢ is a set of cv-qualifiers [[basic.type.qualifier]], and
 each Pᵢ is “pointer to” [[dcl.ptr]], “pointer to member of class Cᵢ of
 type” [[dcl.mptr]], “array of Nᵢ”, or “array of unknown bound of”
 [[dcl.array]]. If Pᵢ designates an array, the cv-qualifiers cvᵢ₊₁ on the
 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 cv-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
-cv-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 cv-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.
-The *cv-combined type* of two types `T1` and `T2` is the type `T3`
-similar to `T1` whose cv-decomposition is such that:
-- for every i > 0, cv³ᵢ is the union of cv¹ᵢ and cv²ᵢ;
 - if either P¹ᵢ or P²ᵢ is “array of unknown bound of”, P³ᵢ is “array of
-  unknown bound of”, otherwise it is P¹ᵢ;
 - if the resulting cv³ᵢ is different from cv¹ᵢ or cv²ᵢ, or the resulting
   P³ᵢ is different from P¹ᵢ or P²ᵢ, then `const` is added to every cv³ₖ
-  for 0 < k < i.
-where cvʲᵢ and Pʲᵢ are the components of the cv-decomposition of `T`j. A
-prvalue of type `T1` can be converted to type `T2` if the cv-combined
-type of `T1` and `T2` is `T2`.
 [*Note 1*:
 If a program could assign a pointer of type `T**` to a pointer of type
 `const` `T**` (that is, if line \#1 below were allowed), a program could
@@ -223,12 +226,12 @@ int main() {
 ```
 — *end note*]
 [*Note 2*: Given similar types `T1` and `T2`, this construction ensures
-that both can be converted to the cv-combined type of `T1` and
-`T2`. — *end note*]
 [*Note 3*: A prvalue of type “pointer to *cv1* `T`” can be converted to
 a prvalue of type “pointer to *cv2* `T`” if “*cv2* `T`” is more
 cv-qualified than “*cv1* `T`”. A prvalue of type “pointer to member of
 `X` of type *cv1* `T`” can be converted to a prvalue of type “pointer to
@@ -239,24 +242,24 @@ 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`, `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 `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 `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`,
@@ -277,12 +280,12 @@ 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 an enumerated 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*.
@@ -312,16 +315,19 @@ The conversions allowed as integral promotions are excluded from the set
 of integral conversions.
 ### Floating-point conversions <a id="conv.double">[[conv.double]]</a>
 A prvalue of floating-point type can be converted to a prvalue of
-another floating-point type. If the source value can be exactly
-represented in the destination type, the result of the conversion is
-that exact representation. If the source value is between two adjacent
-destination values, the result of the conversion is an
-*implementation-defined* choice of either of those values. Otherwise,
-the behavior is undefined.
 The conversions allowed as floating-point promotions are excluded from
 the set of floating-point conversions.
 ### Floating-integral conversions <a id="conv.fpint">[[conv.fpint]]</a>

 ## Standard conversions <a id="conv">[[conv]]</a>
+### General <a id="conv.general">[[conv.general]]</a>
 Standard conversions are implicit conversions with built-in meaning.
 [[conv]] enumerates the full set of such conversions. A *standard
 conversion sequence* is a sequence of standard conversions in the
 following order:
 the descriptions of those operators and contexts. — *end note*]
 ### Lvalue-to-rvalue conversion <a id="conv.lval">[[conv.lval]]</a>
 A glvalue [[basic.lval]] of a non-function, non-array type `T` can be
+converted to a prvalue.[^5]
+If `T` is an incomplete type, a program that necessitates this
+conversion is ill-formed. If `T` is a non-class type, the type of the
+prvalue is the cv-unqualified version of `T`. Otherwise, the type of the
+prvalue is `T`.[^6]
 When an lvalue-to-rvalue conversion is applied to an expression E, and
 either
 - E is not potentially evaluated, or
   `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*]
 — *end example*]
 ### Qualification conversions <a id="conv.qual">[[conv.qual]]</a>
+A *qualification-decomposition* of a type `T` is a sequence of cvᵢ and
+Pᵢ such that `T` is
 where each cvᵢ is a set of cv-qualifiers [[basic.type.qualifier]], and
 each Pᵢ is “pointer to” [[dcl.ptr]], “pointer to member of class Cᵢ of
 type” [[dcl.mptr]], “array of Nᵢ”, or “array of unknown bound of”
 [[dcl.array]]. If Pᵢ designates an array, the cv-qualifiers cvᵢ₊₁ on the
 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.
+The *qualification-combined type* of two types `T1` and `T2` is the type
+`T3` similar to `T1` whose qualification-decomposition is such that:
+- for every i > 0, cv³ᵢ is the union of cv¹ᵢ and cv²ᵢ,
 - if either P¹ᵢ or P²ᵢ is “array of unknown bound of”, P³ᵢ is “array of
+  unknown bound of”, otherwise it is P¹ᵢ, and
 - if the resulting cv³ᵢ is different from cv¹ᵢ or cv²ᵢ, or the resulting
   P³ᵢ is different from P¹ᵢ or P²ᵢ, then `const` is added to every cv³ₖ
+  for 0 < k < i,
+where cvʲᵢ and Pʲᵢ are the components of the qualification-decomposition
+of `T`j. A prvalue of type `T1` can be converted to type `T2` if the
+qualification-combined type of `T1` and `T2` is `T2`.
 [*Note 1*:
 If a program could assign a pointer of type `T**` to a pointer of type
 `const` `T**` (that is, if line \#1 below were allowed), a program could
 ```
 — *end note*]
 [*Note 2*: Given similar types `T1` and `T2`, this construction ensures
+that both can be converted to the qualification-combined type of `T1`
+and `T2`. — *end note*]
 [*Note 3*: A prvalue of type “pointer to *cv1* `T`” can be converted to
 a prvalue of type “pointer to *cv2* `T`” if “*cv2* `T`” is more
 cv-qualified than “*cv1* `T`”. A prvalue of type “pointer to member of
 `X` of type *cv1* `T`” can be converted to a prvalue of type “pointer to
 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`,
 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*.
 of integral conversions.
 ### Floating-point conversions <a id="conv.double">[[conv.double]]</a>
 A prvalue of floating-point type can be converted to a prvalue of
+another floating-point type with a greater or equal conversion rank
+[[conv.rank]]. A prvalue of standard floating-point type can be
+converted to a prvalue of another standard floating-point type.
+If the source value can be exactly represented in the destination type,
+the result of the conversion is that exact representation. If the source
+value is between two adjacent destination values, the result of the
+conversion is an *implementation-defined* choice of either of those
+values. Otherwise, the behavior is undefined.
 The conversions allowed as floating-point promotions are excluded from
 the set of floating-point conversions.
 ### Floating-integral conversions <a id="conv.fpint">[[conv.fpint]]</a>

Diff to HTML by rtfpessoa