Safety concerns about short circuit evaluation [duplicate]

Question

Possible Duplicate:
Is short-circuiting boolean operators mandated in C/C++? And evaluation order?

AFAIK Short circuit evaluation means that a boolean expression is evaluated only up to the point that we can guarantee its outcome.

This is a common idiom in perl where we can write things like: (is_ok() returns non-zero value on "OK")

is_ok() || die "It's not OK!!\n";

instead of

if ( ! is_ok() ) {
    die "It's not OK!!\n";
}

This only works because the order of evaluation is always left-to right and that guarantees that the rightmost statement is only executed if the first statement if not "false".

In C I can do something simillar like:

struct foo {
    int some_flag;
} *ptr = 0;

/* do some work that may change value of ptr */
if ( 0!=ptr && ptr->some_flag ) {
    /* do something */
}

Is it safe to use this kind of idiom?

Or is there any chance that the compiler may generate code that evaluates ptr->some_flag before making sure that ptr is not a zero pointer? (I am assuming that if it is non-null it points to some valid memory region).

This syntax is convenient to use because it saves typing without losing readability (in my opinion anyway). However I'm not sure if it is entirely safe which is why I'd like to learn more on this.

NB: If the compiler has an effect on this, I'm using gcc 4.x

Answer 1

The evaluation order of short-circuit operators (|| and &&) is guaranteed by the standard to be left to right (otherwise they would lose part of their usefulness).

§6.5.13 ¶4

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.

§6.5.14 ¶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.