[expr.cond] - C++14 → C++17

Files changed (1) hide show

tmp/tmp43y2j8ko/{from.md → to.md} +52 -46

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

@@ -17,60 +17,67 @@ the second or third expression.
 If either the second or the third operand has type `void`, one of the
 following shall hold:
 - The second or the third operand (but not both) is a (possibly
-  parenthesized) *throw-expression* ([[except.throw]]); the result is
- of the type and value category of the other.
 - Both the second and the third operands have type `void`; the result is
-  of type `void` and is a prvalue. This includes the case where both
-  operands are *throw-expression*s.
 Otherwise, if the second and third operand have different types and
 either has (possibly cv-qualified) class type, or if both are glvalues
 of the same value category and the same type except for
-cv-qualification, an attempt is made to convert each of those operands
-to the type of the other. The process for determining whether an operand
-expression `E1` of type `T1` can be converted to match an operand
-expression `E2` of type `T2` is defined as follows:
-- If `E2` is an lvalue: `E1` can be converted to match `E2` if `E1` can
-  be implicitly converted (Clause  [[conv]]) to the type “lvalue
-  reference to `T2`”, subject to the constraint that in the conversion
-  the reference must bind directly ([[dcl.init.ref]]) to an lvalue.
-- If `E2` is an xvalue: `E1` can be converted to match `E2` if `E1` can
-  be implicitly converted to the type “rvalue reference to `T2`”,
   subject to the constraint that the reference must bind directly.
-- If `E2` is a prvalue or if neither of the conversions above can be
- done and at least one of the operands has (possibly cv-qualified)
-  class type:
-  - if `E1` and `E2` have class type, and the underlying class types are
- the same or one is a base class of the other: `E1` can be converted
- to match `E2` if the class of `T2` is the same type as, or a base
-    class of, the class of `T1`, and the cv-qualification of `T2` is the
- same cv-qualification as, or a greater cv-qualification than, the
- cv-qualification of `T1`. If the conversion is applied, `E1` is
- changed to a prvalue of type `T2` by copy-initializing a temporary
-    of type `T2` from `E1` and using that temporary as the converted
-    operand.
-  - Otherwise (i.e., if `E1` or `E2` has a nonclass type, or if they
-    both have class types but the underlying classes are not either the
-    same or one a base class of the other): `E1` can be converted to
-    match `E2` if `E1` can be implicitly converted to the type that
-    expression `E2` would have if `E2` were converted to a prvalue (or
-    the type it has, if `E2` is a prvalue).
-Using this process, it is determined whether the second operand can be
-converted to match the third operand, and whether the third operand can
-be converted to match the second operand. If both can be converted, or
-one can be converted but the conversion is ambiguous, the program is
-ill-formed. If neither can be converted, the operands are left unchanged
-and further checking is performed as described below. If exactly one
-conversion is possible, that conversion is applied to the chosen operand
 and the converted operand is used in place of the original operand for
 the remainder of this section.
 If the second and third operands are glvalues of the same value category
 and have the same type, the result is of that type and value category
 and it is a bit-field if the second or the third operand is a bit-field,
 or if both are bit-fields.
@@ -87,21 +94,20 @@ Lvalue-to-rvalue ([[conv.lval]]), array-to-pointer ([[conv.array]]),
 and function-to-pointer ([[conv.func]]) standard conversions are
 performed on the second and third operands. After those conversions, one
 of the following shall hold:
 - The second and third operands have the same type; the result is of
-  that type. If the operands have class type, the result is a prvalue
- temporary of the result type, which is copy-initialized from either
-  the second operand or the third operand depending on the value of the
-  first operand.
 - The second and third operands have arithmetic or enumeration type; the
   usual arithmetic conversions are performed to bring them to a common
   type, and the result is of that type.
 - One or both of the second and third operands have pointer type;
-  pointer conversions ([[conv.ptr]]) and qualification conversions (
-  [[conv.qual]]) are performed to bring them to their composite pointer
- type (Clause  [[expr]]). The result is of the composite pointer type.
 - One or both of the second and third operands have pointer to member
   type; pointer to member conversions ([[conv.mem]]) and qualification
   conversions ([[conv.qual]]) are performed to bring them to their
   composite pointer type (Clause  [[expr]]). The result is of the
   composite pointer type.

 If either the second or the third operand has type `void`, one of the
 following shall hold:
 - The second or the third operand (but not both) is a (possibly
+  parenthesized) *throw-expression* ([[expr.throw]]); the result is of
+  the type and value category of the other. The *conditional-expression*
+  is a bit-field if that operand is a bit-field.
 - Both the second and the third operands have type `void`; the result is
+  of type `void` and is a prvalue. \[*Note 1*: This includes the case
+ where both operands are *throw-expression*s. — *end note*]
+Otherwise, if the second and third operand are glvalue bit-fields of the
+same value category and of types *cv1* `T` and *cv2* `T`, respectively,
+the operands are considered to be of type *cv* `T` for the remainder of
+this section, where *cv* is the union of *cv1* and *cv2*.
 Otherwise, if the second and third operand have different types and
 either has (possibly cv-qualified) class type, or if both are glvalues
 of the same value category and the same type except for
+cv-qualification, an attempt is made to form an implicit conversion
+sequence ([[over.best.ics]]) from each of those operands to the type of
+the other.
+[*Note 2*: Properties such as access, whether an operand is a
+bit-field, or whether a conversion function is deleted are ignored for
+that determination. — *end note*]
+Attempts are made to form an implicit conversion sequence from an
+operand expression `E1` of type `T1` to a target type related to the
+type `T2` of the operand expression `E2` as follows:
+- If `E2` is an lvalue, the target type is “lvalue reference to `T2`”,
+  subject to the constraint that in the conversion the reference must
+  bind directly ([[dcl.init.ref]]) to an lvalue.
+- If `E2` is an xvalue, the target type is “rvalue reference to `T2`”,
   subject to the constraint that the reference must bind directly.
+- If `E2` is a prvalue or if neither of the conversion sequences above
+ can be formed and at least one of the operands has (possibly
+ cv-qualified) class type:
+  - if `T1` and `T2` are the same class type (ignoring
+ cv-qualification), or one is a base class of the other, and `T2` is
+ at least as cv-qualified as `T1`, the target type is `T2`,
+  - otherwise, the target type is the type that `E2` would have after
+ applying the lvalue-to-rvalue ([[conv.lval]]), array-to-pointer (
+ [[conv.array]]), and function-to-pointer ([[conv.func]]) standard
+ conversions.
+Using this process, it is determined whether an implicit conversion
+sequence can be formed from the second operand to the target type
+determined for the third operand, and vice versa. If both sequences can
+be formed, or one can be formed but it is the ambiguous conversion
+sequence, the program is ill-formed. If no conversion sequence can be
+formed, the operands are left unchanged and further checking is
+performed as described below. Otherwise, if exactly one conversion
+sequence can be formed, that conversion is applied to the chosen operand
 and the converted operand is used in place of the original operand for
 the remainder of this section.
+[*Note 3*: The conversion might be ill-formed even if an implicit
+conversion sequence could be formed. — *end note*]
 If the second and third operands are glvalues of the same value category
 and have the same type, the result is of that type and value category
 and it is a bit-field if the second or the third operand is a bit-field,
 or if both are bit-fields.
 and function-to-pointer ([[conv.func]]) standard conversions are
 performed on the second and third operands. After those conversions, one
 of the following shall hold:
 - The second and third operands have the same type; the result is of
+  that type and the result object is initialized using the selected
+ operand.
 - The second and third operands have arithmetic or enumeration type; the
   usual arithmetic conversions are performed to bring them to a common
   type, and the result is of that type.
 - One or both of the second and third operands have pointer type;
+  pointer conversions ([[conv.ptr]]), function pointer conversions (
+  [[conv.fctptr]]), and qualification conversions ([[conv.qual]]) are
+ performed to bring them to their composite pointer type (Clause
+  [[expr]]). The result is of the composite pointer type.
 - One or both of the second and third operands have pointer to member
   type; pointer to member conversions ([[conv.mem]]) and qualification
   conversions ([[conv.qual]]) are performed to bring them to their
   composite pointer type (Clause  [[expr]]). The result is of the
   composite pointer type.

Diff to HTML by rtfpessoa