«

I have an if statement that looks like this:

if(foo(&x) && x > y)
...

where the value of x is modified by foo, and the comparison between x
and y only makes sense after x has been modified by foo (and, of
course, if foo returns true). Am I guaranteed (assuming my compiler
generates correct code) that x > y is evaluated after foo(&x) returns?

Assuming things work the way I think they do, is it considered bad form
to write code like this? It saves me from doing something like the
following, which I think is ugly-looking:

if(foo(&x))
{
if(x > y)
{
...
}
}

Thanks,
Tim

tconkling wrote:
> I have an if statement that looks like this:
>
> if(foo(&x) && x > y)
> ...
>
> where the value of x is modified by foo, and the comparison between x
> and y only makes sense after x has been modified by foo (and, of
> course, if foo returns true). Am I guaranteed (assuming my compiler
> generates correct code) that x > y is evaluated after foo(&x) returns?

Yes in some sense. The order of evaluation is lexicographic, so first

foo(&x)

and *IF* foo is true then is (x > y) evaluated, otherwise it goes rigth
to the else statement.

> Assuming things work the way I think they do, is it considered bad form
> to write code like this? It saves me from doing something like the
> following, which I think is ugly-looking:
>
> if(foo(&x))
> {
> if(x > y)
> {
> ...
> }
> }

They are equivalent.

tconkling wrote:
> I have an if statement that looks like this:
>
> if(foo(&x) && x > y)
> ...
>
> where the value of x is modified by foo, and the comparison between x
> and y only makes sense after x has been modified by foo (and, of
> course, if foo returns true). Am I guaranteed (assuming my compiler
> generates correct code) that x > y is evaluated after foo(&x) returns?
>
> Assuming things work the way I think they do, is it considered bad form
> to write code like this? It saves me from doing something like the
> following, which I think is ugly-looking:
>
> if(foo(&x))
> {
> if(x > y)
> {
> ...
> }
> }
>
> Thanks,
> Tim
>
Yes, those forms are equivalent. Of course, you don't need the braces
around the inner if().

"tconkling" <> writes:
> I have an if statement that looks like this:
>
> if(foo(&x) && x > y)
> ...
>
> where the value of x is modified by foo, and the comparison between x
> and y only makes sense after x has been modified by foo (and, of
> course, if foo returns true). Am I guaranteed (assuming my compiler
> generates correct code) that x > y is evaluated after foo(&x) returns?
>
> Assuming things work the way I think they do, is it considered bad form
> to write code like this? It saves me from doing something like the
> following, which I think is ugly-looking:
>
> if(foo(&x))
> {
> if(x > y)
> {
> ...
> }
> }

Yes, that's a special property of the "&&" operator (also "||" and
","). The "&&" operator evaluates its left operand first, then
evaluates the right operand only of the left operand evaluted to a
non-zero value. There's also a sequence point between the evaluation
of the left and right operands.

--
Keith Thompson (The_Other_Keith) kst- <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.