CATEGORII DOCUMENTE  


The && and  operators are called the conditional logical operators. They are also called the “shortcircuiting” logical operators.
conditionalandexpression:
inclusiveorexpression
conditionalandexpression && inclusiveorexpression
conditionalorexpression:
conditionalandexpression
conditionalorexpression  conditionalandexpression
The && and  operators are conditional versions of the & and  operators:
The operation x && y corresponds to the operation x & y, except that y is evaluated only if x is true.
The operation x  y corresponds to the operation x  y, except that y is evaluated only if x is false.
An operation of the form x && y or x  y is processed by applying overload resolution (§7.2.4) as if the operation was written x & y or x  y. Then,
If overload resolution fails to find a single best operator, or if overload resolution selects one of the predefined integer logical operators, an error occurs.
Otherwise, if the selected operator is one of the predefined boolean logical operators (§7.10.2), the operation is processed as described in §7.11.1.
Otherwise, the selected operator is a userdefined operator, and the operation is processed as described in §7.11.2.
It is not possible to directly overload the conditional logical operators. However, because the conditional logical operators are evaluated in terms of the regular logical operators, overloads of the regular logical operators are, with certain restrictions, also considered overloads of the conditional logical operators. This is described further in §7.11.2.
When the operands of && or  are of type bool, or when the operands are of types that do not define an applicable operator & or operator , but do define implicit conversions to bool, the operation is processed as follows:
The operation x && y is evaluated as x? y: false. In other words, x is first evaluated and converted to type bool. Then, if x is true, y is evaluated and converted to type bool, and this becomes the result of the operation. Otherwise, the result of the operation is false.
The operation x  y is evaluated as x? true: y. In other words, x is first evaluated and converted to type bool. Then, if x is true, the result of the operation is true. Otherwise, y is evaluated and converted to type bool, and this becomes the result of the operation.
When the operands of && or  are of types that declare an applicable userdefined operator & or operator , both of the following must be true, where T is the type in which the selected operator is declared:
The return type and the type of each parameter of the selected operator must be T. In other words, the operator must compute the logical AND or the logical OR of two operands of type T, and must return a result of type T.
T must contain declarations of operator true and operator false.
A compiletime error occurs if either of these requirements is not satisfied. Otherwise, the && or  operation is evaluated by combining the userdefined operator true or operator false with the selected userdefined operator:
The operation x && y is evaluated as T.false(x)? x: T.&(x, y), where T.false(x) is an invocation of the operator false declared in T, and T.&(x, y) is an invocation of the selected operator &. In other words, x is first evaluated and operator false is invoked on the result to determine if x is definitely false. Then, if x is definitely false, the result of the operation is the value previously computed for x. Otherwise, y is evaluated, and the selected operator & is invoked on the value previously computed for x and the value computed for y to produce the result of the operation.
The operation x  y is evaluated as T.true(x)? x: T.(x, y), where T.true(x) is an invocation of the operator true declared in T, and T.(x, y) is an invocation of the selected operator . In other words, x is first evaluated and operator true is invoked on the result to determine if x is definitely true. Then, if x is definitely true, the result of the operation is the value previously computed for x. Otherwise, y is evaluated, and the selected operator  is invoked on the value previously computed for x and the value computed for y to produce the result of the operation.
In either of these operations, the expression given by x is only evaluated once, and the expression given by y is either not evaluated or evaluated exactly once.
For an example of a type that implements operator true and operator false, see §11.4.2.
Politica de confidentialitate 
Vizualizari: 492
Importanta:
Termeni si conditii de utilizare  Contact
© SCRIGROUP 2021 . All rights reserved
Distribuie URL
Adauga cod HTML in site