Order of execution for an if with multiple conditionals
In an if statement with multiple conditionals, is the second conditional executed if the outcome of the first is clear?
example:
if(i>0 && array[i]==0){
}
If I swap the conditionals a segfault may occur for negative values of i, but this way no segfault occurs. Can I be sure that this always works or do have have to use nested if statements?
Solution 1:
This type of evaluation is called short-circuiting. Once the result is 100% clear, it does not continue evaluating.
This is actually a common programming technique. For example, in C++ you will often see something like:
if (pX!=null && pX->predicate()) { bla bla bla }
If you changed the order of the conditions, you could be invoking a method on a null pointer and crashing. A similar example in C would use the field of a struct when you have a pointer to that struct.
You could do something similar with or:
if(px==null || pX->isEmpty()} { bla bla bla }
This is also one of the reasons that it is generally a good idea to avoid side effects in an if condition.
For example suppose you have:
if(x==4 && (++y>7) && z==9)
If x
is 4
, then y
will be incremented regardless of the value of z
or y
, but if x
is not 4
, it will not be incremented at all.
Solution 2:
The operators &&
and ||
guarantee that the left-hand side expression will be fully evaluated (and all side effects applied) before the right-hand side is evaluated. In other words, the operators introduce a sequence point.
Additionally, if the value of the expression can be determined from the lhs, the rhs is not evaluated. In other words, if you have an expression like x && y
, and x evaluates to 0 (false), then the value of the expression is false regardless of y, so y is not evaluated.
This means that expressions like x++ && x++
are well-defined, since &&
introduces a sequence point.