Conditional expressions group right-to-left.
evaluated and if it is true
, the result of the conditional
expression is the value of the second expression, otherwise that of the
Only one of the second and third expressions is
The first expression is sequenced before
the second or third expression ([intro.execution]
Otherwise, if the second and third operand are glvalue bit-fields
of the same value category and
of types cv1 T
and cv2 T
the operands are considered to be of type cv T
for the remainder of this subclause,
is the union of cv1
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
each of those operands to the type of the other.
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
is an lvalue, the target type is
“lvalue reference to T2
”, subject to the
constraint that in the conversion the reference must bind
) to a glvalue.
is an xvalue, the target type is
“rvalue reference to T2
subject to the constraint that the reference must bind directly.
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) and
T2 is at least as cv-qualified as T1,
the target type is T2,
- otherwise, if T2 is a base class of T1,
the target type is cv1 T2, where cv1
denotes the cv-qualifiers of T1,
- otherwise, the target type is the type that E2 would have
after applying the
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 subclause.
The conversion might be ill-formed even if an implicit conversion
sequence could be formed.
— end note
Otherwise, the result is a prvalue.
If the second and third operands do
not have the same type, and either has (possibly cv-qualified) class
type, overload resolution is used to determine the conversions (if any)
to be applied to the operands ([over.match.oper]
If the overload resolution fails, the program is ill-formed.
the conversions thus determined are applied, and the converted operands
are used in place of the original operands for the remainder of this