How Is If Statement Evaluated in C++

How is if statement evaluated in c++?

No, if (c) is the same as if (c != 0).
And if (!c) is the same as if (c == 0).

How does the compiler evaluate a condition in C

According to the C Standard (6.5.13 Logical AND operator)

4 Unlike the bitwise binary & operator, the && operator guarantees
left-to-right evaluation; if the second operand is evaluated, there is
a sequence point between the evaluations of the first and second
operands. If the first operand compares equal to 0, the second operand
is not evaluated.

As for the logical OR operator (6.5.14 Logical OR operator) then

4 Unlike the bitwise | operator, the || operator guarantees
left-to-right evaluation; if the second operand is evaluated, there is
a sequence point between the evaluations of the first and second
operands. If the first operand compares unequal to 0, the second
operand is not evaluated.

What is the order of evaluation of statements in a if bracket if(...)?

The order of evaluation for || is from left to right, as Eric mentions this is a special property of || and &&, most operators do not enforce left to right evalation. It will not evaluate the right expression if the left one succeeds, from the C99 draft standard section 6.5.14 paragraph 4:

Unlike the bitwise | operator, the || operator guarantees left-to-right evaluation; there is a sequence point after the evaluation of the first operand. If the first operand compares unequal to 0, the second operand is not evaluated.

The C++ draft standard has similar language in section 5.15 paragraph 1.

IF argument evaluation order?

The evaluation order is specified by the standard and is left-to-right. The left-most expression will always be evaluated first with the && clause.

If you want b to be evaluated first:

if(b && a)
{
  //do something
}

If both arguments are methods and you want both of them to be evaluated regardless of their result:

bool rb = b();
bool ra = a();

if ( ra && rb )
{
  //do something
}

if statement in c++ doesn't evaluate conditions from left to right

Division-by-zero is undefined behavior. Anything can happen.

[expr.mul]/4

If the second operand of / or % is zero the behavior is undefined.

Does if (!(-1)) evaluate to true or false in C?

The evaluation of if (!(-1)) can be worked out by thinking about the operator precedences.

Firstly the unary - is applied to 1 which produces an integral -1. Then this value is logically negated by the !. This involves collapsing -1 into a logical value. The rule for this in C is nice and simple for integral types: 0 is falsy and everything else is truthy.

Therefore -1 is truthy and when the logical negation happens we get false.

Therefore this statement is portably false.

Is an if statement guaranteed to not be evaluated more than necessary?

But if the first condition resolves to false, it the second condition guaranteed to not get evaluated?

Yes, that's C++'s short circuiting. Per paragraph 5.14/1 of the C++11 Standard:

The && operator groups left-to-right. The operands are both contextually converted to bool (Clause 4).
The result is true if both operands are true and false otherwise. Unlike &, && guarantees left-to-right
evaluation: the second operand is not evaluated if the first operand is false.

As MatthieuM. correctly mentions in the comments, the above applies only to the built-in logical AND and logical OR operators: if those operators are overloaded, invoking them is treated as a regular function call (so no short-circuiting applies and no order of evaluation is guaranteed).

As specified in paragraph 5/2:

[Note: Operators can be overloaded, that is, given meaning when applied to expressions of class type (Clause
9) or enumeration type (7.2). Uses of overloaded operators are transformed into function calls as described
in 13.5. Overloaded operators obey the rules for syntax specified in Clause 5, but the requirements of
operand type, value category, and evaluation order are replaced by the rules for function call. [...] —end note ]

Does an IF-Statement checks every OR operator?

C++ uses what is known as short-circuit expression evaluation, which means that as soon as it encounters a term which determines the final result of the expression, (regardless of what the remaining terms may evaluate to,) it will stop evaluating terms.

Since TRUE OR X is TRUE regardless of the value of X, C++ will not bother evaluating X.

However, your cascaded if statement is not equivalent to the first expression. It is equivalent to an expression with multiple ANDs not multiple ORs.

---

Related Topics