Question

Possible Duplicate:
Safety concerns about short circuit evaluation

What does the standard say about evaluating && expressions – does it guarantee that evaluation of parameters will stop at the first false?

E.g.:

Foo* p;
//....
if ( p && p->f() )
{
    //do something
}

is the f() guaranteed not to be called if p == NULL?

Also, is the order of evaluation guaranteed to be the order of appearence in the clause?

Might the optimizer change something like:

int x;
Foo* p;
//...
if ( p->doSomethingReallyExpensive() && x == 3 )
{
    //....
}

to a form where it evaluates x==3 first? Or will it always execute the really expensive function first?

I know that on most compilers (probably all) evaluation stops after the first false is encountered, but what does the standard say about it?

Answer 1

What does the standard say about evaluating && expressions – does it guarantee that evaluation of parameters will stop at the first false?

Yes. That is called short-circuiting.

Also, is the order of evaluation guaranteed to be the order of appearence in the clause?

Yes. From left to right. The operand before which the expression short-circuited doesn’t get evaluated.

int a = 0;
int b = 10;
if ( a != 0 && (b=100)) {}

cout << b << endl; //prints 10, not 100

In fact, the above two points are the keypoint in my solution here:

• Find maximum of three number in C without using conditional statement and ternary operator