Philip Potter wrote:
> Aggro wrote:
>> I would like to know the answer to this for both C and C++ as I use
both
>> languages (usually in differen projects).
>>
>> Assume the code
>> if( A && B )
>>
>> Normally A is executed before B and this is how I have always believed
>> it is guaranteed to work. But recently I got second hand information
>> that the execution order is not quaranteed. E.g. B could be executed
>> before A by some compilers.
>>
>> Different execution order could cause e.g. application to crash if we
>> first test is the pointer valid and then call a function for that
pointer:
>> if( p && p->func() )
>>
>>
>> So. Is the execution order guaranteed by the standard in both C and C++
>> to be first A and then B or can it change e.g. because of optimization?
>> Should I start writing my code in this format to be safe?
>>
>> if( p )
>> if( p->func() )
>> ...
>
> Ulrich has answered your question; in C (and probably C++, though I'm
> not a C++ expert) both && and || are guaranteed to be executed
> left-to-right; and if the result can be generated based on the LHS
> alone, the RHS is guaranteed not to be evaluated. Moreover, && and ||
> introduce a sequence point between LHS and RHS, so expressions such as
> (p && x = *p++) are valid (though not recommended).
>
> Few operators (except ?:, the comma operator, and probably one or two
> I've forgotten) have similar semantics. The order of evaluation of the
> arguments of most operators is unspecified; in particular, f(x) * 0 and
> 0 * f(x) may (will?) call f() in either case, even though the result
> will always be zero. Similarly A & 0 and 0 & A have no guarantees over
> order of evaluation and no sequence points. And finally, x++ * x++ is
> undefined behaviour, even though x++ || x++ or x++ && x++ are
well-defined.
>
> Only && and || are "magical" in this way.
However let me re-emphasise that in C++ && and || cn be overloaded by
user written functions when lazy evaluation does NOT happen. It is only
the built in versions of those operators that require strict evaluation
of the left operand first.
|
