EXP07-J. Understand the differences between bitwise and logical operators

The conditional AND and OR operators (&& and ||, respectively) exhibit short-circuit behavior. That is, the second operand is evaluated only when the result of the conditional operator cannot be deduced solely by evaluating the first operand. Consequently, when the result of the conditional operator can be deduced solely from the result of the first operand, the second operand will remain unevaluated; its side-effects, if any, will never occur.

The bitwise AND and OR operators (& and |) do not exhibit this behavior. Like most other Java operators, they evaluate both operands, first the left operand, and then the right. They return the same Boolean result as && and || respectively, but can have different overall effect depending on the presence or absence of side-effects in the second operand.

Consequently either the & or the && operator can be used when performing Boolean logic. However, there are times when the short-circuiting behavior is preferred, and other times when the short-circuiting behavior causes subtle bugs.

Noncompliant Code Example (Improper &)

This noncompliant code example, derived from Flanagan [[Flanagan 2005]], has two variables, with no guarantees regarding their current values. The code must validate its data and then check whether array[i] is nonnegative.

int array[]; // may be null
int i;       // may be a valid index for array
if (array != null &
    i >= 0 & i < array.length &
    array[i] >= 0) {
  // handle array
} else {
  // handle error
}

This code can fail due to the very errors it is attempting to prevent. When array is null or when i is not a valid index, the reference to array[i] will cause a NullPointerException or an ArrayIndexOutOfBoundsException to be thrown. This happens because the & operator fails to prevent evaluation of its right operand, even when evaluation of its left operand proves that the right operand is invalid.

Compliant Solution (Use &&)

This compliant solution mitigates the problem by using &&, which causes the conditional expression to terminate immediately if any of the conditions fail, thereby preventing a potentially-invalid evaluation.

int array[]; // may be null
int i;       // may be a valid index for array
if (array != null &&
    i >= 0 & i < array.length &&
    array[i] >= 0) {
  // handle array
} else {
  // handle error
}

Compliant Solution (Nested If Statements)

This compliant solution uses multiple if statements to achieve the proper effect. While correct, it is more verbose and may be more difficult to maintain.

int array[]; // may be null
int i;       // may be a valid index for array
if (data != null) {
  if (i >= 0 & i < data.length) {
    if (data[i] != -1) {
     // handle array
    } else {
      // handle error
    }
  } else {
    // handle error
  }
} else {
  // handle error
}

Nevertheless, this solution would be useful if the error-handling routines for each potential condition failure were different.

Noncompliant Code Example (Improper &&)

This noncompliant code example demonstrates code that compares two arrays for ranges of members that match. Here i1 and i2 are valid array indices in array1 and array2 respectively. It is expected that end1 and end2 will point to the end of the matching ranges in the two arrays.

if (end1 >= 0 & i2 >= 0) {
  int begin1 = i1;
  int begin2 = i2;
  while (++i1 < array1.length &&
         ++i2 < array2.length &&
         array1[i1] == array2[i2]) {
    // arrays match so far
  }
  int end1 = i1;
  int end2 = i2;
  assert end1 - begin1 == end2 - begin2;
}

The problem with this code is that when the first condition in the while loop fails, the second condition is not executed. That is, once i1 has reached array1.length, the loop may terminate after i1 is executed. Consequently the range over array1 is larger than the range over array2, causing the final assertion to fail.

Compliant Solution (Use &)

This compliant solution mitigates the problem by using &, which guarantees that both i1 and i2 are incremented, regardless of the outcome of the first condition.

  while (++i1 < array1.length &     // not &&
         ++i2 < array2.length &&
         array1[i1] == array2[i2])

Compliant Solution (Nested If Statements)

This compliant solution uses multiple if statements to achieve the proper effect. While correct, it is more verbose.

  while (true) {
    if (++i1 >= array1.length) break;
    if (++i2 >= array2.length) break;
    if (array1[i1] != array2[i2]) break;
    // rest of loop
  }

Risk Assessment

Failure to understand the behavior of the bitwise and conditional operators can cause unintended program behavior.

Related Guidelines

CERT C Secure Coding Standard: EXP02-C. Be aware of the short-circuit behavior of the logical AND and OR operators
CERT C++ Secure Coding Standard: EXP02-CPP. Be aware of the short-circuit behavior of the logical AND and OR operators

Bibliography

[[Flanagan 2005]] 2.5.6. Boolean Operators
[[JLS 2005]] Sections 15.23 "Conditional-And Operator &&" and 15.24 "Conditional-Or Operator ||"

EXP06-J. Use parentheses for precedence of operation      Expressions (EXP)      EXP08-J. Understand the evaluation of expressions containing non-short-circuit operators