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

Files changed (1) hide show

tmp/tmp31z3ad9p/{from.md → to.md} +25 -29

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

@@ -13,19 +13,16 @@ of the second expression, otherwise that of the third expression. Only
 one of the second and third expressions is evaluated. Every value
 computation and side effect associated with the first expression is
 sequenced before every value computation and side effect associated with
 the second or third expression.
-If either the second or the third operand has type `void`, then the
-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, and one of the following
-shall hold:
-- The second or the third operand (but not both) is a
-  *throw-expression* ([[except.throw]]); the result is of the type of
-  the other and is a prvalue.
 - 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
@@ -41,11 +38,11 @@ expression `E2` of type `T2` is defined as follows:
   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 an rvalue 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
@@ -61,18 +58,18 @@ expression `E2` of type `T2` is defined as follows:
     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.
@@ -97,19 +94,18 @@ of the following shall hold:
   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.
-- The second and third operands have pointer type, or one has pointer
- type and the other is a null pointer constant, or both are null
-  pointer constants, at least one of which is non-integral; pointer
-  conversions ([[conv.ptr]]) and qualification conversions (
   [[conv.qual]]) are performed to bring them to their composite pointer
-  type ([[expr.rel]]). The result is of the composite pointer type.
-- The second and third operands have pointer to member type, or one has
-  pointer to member type and the other is a null pointer constant;
- pointer to member conversions ([[conv.mem]]) and qualification
- conversions ([[conv.qual]]) are performed to bring them to a common
- type, whose cv-qualification shall match the cv-qualification of
-  either the second or the third operand. The result is of the common
-  type.

 one of the second and third expressions is evaluated. Every value
 computation and side effect associated with the first expression is
 sequenced before every value computation and side effect associated with
 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
   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
     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.
   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.
+- Both the second and third operands have type `std::nullptr_t` or one
+ has that type and the other is a null pointer constant. The result is
+  of type `std::nullptr_t`.

Diff to HTML by rtfpessoa