[RESOLVED] order of evaluation of condition expression.

[indrajit_p1]

Hi all,

I have written some production level code assuming that if there is something like

if ( condition A || condition B || condition C)

or 

if ( condition A && condition B && condition C)

the conditions will be evaluated left to right. i.e. A first, B next and C last.

Someone who reviewed my code from Ireland has commented that the standards don't guarantee any such thing.

I have found this in the K&R, which says: C does not guarantee the order of evaluation of expressions other than for ||, &&, comma and the ?: operators.

Can someone who is conversant with the current standards let me know if I am right or wrong?

I

[Hobson]

Logical operators, WHEN NOT OVERLOADED, have some special property: they are evaluated left to right, and when evaluation yields the result which will be not affected by following expressions, it is terminated. So when you have something like this:

T* object = getObject(); //returns NULL on failure
if(object && object->getSomeProperty() == "value") {
   //...
}

it is guarenteed that program will not try to invoke member function, if pointer points to NULL. It is called short-circuit evaluation and occurs only for non-overloaded operators && and ||.
Comma and conditional operators also have guaranted order of expression evaluation, unless overloaded.
Remaining operators, either overloaded or not, have unspecified order of subexpression evaluation.

Cheers

[Graham]

The operators || and && are "short-circuit" operators. This means that as soon as the result is guaranteed (working from left to right), it stops evaluating. Essentially it means that this

if (ptr && ptr->mem_fun())

is safe - if ptr == 0, then it will not attempt to dereference it.

And yes, the comma and ternary operators behave similarly.

Here's the entry for the logical AND operator from the standard:

1. The && operator groups left-to-right. The operands are both implicitly converted to type 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.

2. The result is a bool. All side effects of the first expression except for destruction of temporaries (12.2) happen before the second expression is evaluated.

[laserlight]

Both C++03 and C99 guarantee left-to-right evaluation for || and &&. If you want to quote them:

The && operator groups left-to-right. The operands are both implicitly converted to type 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.

The || operator groups left-to-right. The operands are both implicitly converted to bool (clause 4). It returns true if either of its operands is true, and false otherwise. Unlike |, || guarantees left-to-right evaluation; moreover, the second operand is not evaluated if the first operand evaluates to true.

Unlike the bitwise binary & 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 equal to 0, the second operand is not evaluated.

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.

[indrajit_p1]

Thanks a LOT Graham and particularly laserlight for giving me the exact references.
I

[TheCPUWizard]

Just remember (as previously pointed out), the quoted parts of the standard ONLY apply for "non-overloaded" operators. This means that if you create your own "operator &&" or ""operator ||" you will NOT have the short-circuit behaviour.

So without knowing the TYPES of "ConditionA", "ConditionB" and "ConditionC" it is actually impossible to tell if the ordering and short-circuit apply...

[Graham]

And this is why Meyers recommends never overloading logical AND, logical OR or comma (you can't overload the ternary operator).

[indrajit_p1]

Meyer's is....can't find words ( all good words fall short of describing his metel).
I