Editing Short-circuit evaluation (section)

===Avoiding undesired side effects of the second argument===
Usual example, using a [[C (programming language)|C-based]] language:
<syntaxhighlight lang="c">
int denom = 0;
if (denom != 0 && num / denom)
{
    ... // ensures that calculating num/denom never results in divide-by-zero error   
}
</syntaxhighlight>

Consider the following example:
<syntaxhighlight lang="c">
int a = 0;
if (a != 0 && myfunc(b))
{
    do_something();
}
</syntaxhighlight>

In this example, short-circuit evaluation guarantees that <code>myfunc(b)</code> is never called. This is because <code>a != 0</code> evaluates to ''false''. This feature permits two useful programming constructs.

# If the first sub-expression checks whether an expensive computation is needed and the check evaluates to ''false'', one can eliminate expensive computation in the second argument. 
# It permits a construct where the first expression guarantees a condition without which the second expression may cause a [[run-time error]].

Both are illustrated in the following C snippet where minimal evaluation prevents both null pointer dereference and excess memory fetches:
<syntaxhighlight lang="cpp">
bool is_first_char_valid_alpha_unsafe(const char *p)
{
    return isalpha(p[0]); // SEGFAULT highly possible with p == NULL
}

bool is_first_char_valid_alpha(const char *p)
{
    return p != NULL && isalpha(p[0]); // 1) no unneeded isalpha() execution with p == NULL, 2) no SEGFAULT risk
}
</syntaxhighlight>