EXP45-C. Do not perform assignments in selection statements

Do not use the assignment operator in the contexts listed in the following table because doing so typically indicates programmer error and can result in unexpected behavior.

Noncompliant Code Example

In this noncompliant code example, an assignment expression is the outermost expression in an if statement:

if (a = b) {
  /* ... */
}

Although the intent of the code may be to assign b to a and test the value of the result for equality to 0, it is frequently a case of the programmer mistakenly using the assignment operator = instead of the equals operator ==. Consequently, many compilers will warn about this condition, making this coding error detectable by adhering to MSC00-C. Compile cleanly at high warning levels.

Compliant Solution (Unintentional Assignment)

When the assignment of b to a is not intended, this conditional block is now executed when a is equal to b:

if (a == b) {
  /* ... */
}

Compliant Solution (Intentional Assignment)

When the assignment is intended, this compliant solution explicitly uses inequality as the outermost expression while performing the assignment in the inner expression:

if ((a = b) != 0) {
  /* ... */
}

It is less desirable in general, depending on what was intended, because it mixes the assignment in the condition, but it is clear that the programmer intended the assignment to occur.

Noncompliant Code Example

In this noncompliant code example, the expression x = y is used as the controlling expression of the while statement:

 do { /* ... */ } while (foo(), x = y);

The same result can be obtained using the for statement, which is specifically designed to evaluate an expression on each iteration of the loop, just before performing the test in its controlling expression:

 for (; x; foo(), x = y) { /* ... */ }

Compliant Solution (Unintentional Assignment)

When the assignment of y to x is not intended, this conditional block is now executed when x is equal to y, as in this compliant solution:

do { /* ... */ } while (foo(), x == y); 

Compliant Solution (Intentional Assignment)

When the assignment is intended, this compliant solution can be used:

do { /* ... */ } while (foo(), (x = y) != 0);

Noncompliant Code Example

In this noncompliant example, the expression p = q is used as the controlling expression of the while statement:

 do { /* ... */ } while (x = y, p = q);

Compliant Solution

In this compliant solution, the expression x = y is not used as the controlling expression of the while statement:

do { /* ... */ } while (x = y, p == q); 

Exceptions

EXP45-EX1: Assignment can be used where the result of the assignment is itself an operand to a comparison expression or relational expression. In this compliant example, the expression x = y  is itself an operand to a comparison operation:

if ((x = y) != 0) { /* ... */ } 

EXP45-EX2: Assignment can be used where the expression consists of a single primary expression. The following code is compliant because the expression  x = y is a single primary expression:

if ((x = y)) { /* ... */ } 

The following controlling expression is noncompliant because && is not a comparison or relational operator and the entire expression is not primary:

if ((v = w) && flag) { /* ... */ } 

When the assignment of v to w is not intended, the following controlling expression can be used to execute the conditional block when v is equal to w:

if ((v == w) && flag) { /* ... */ }; 

When the assignment is intended, the following controlling expression can be used:

if (((v = w) != 0) && flag) { /* ... */ }; 

EXP45-EX3: Assignment can be used in a function argument or array index. In this compliant solution, the expression x = y is used in a function argument:

if (foo(x = y)) { /* ... */ } 

Errors of omission can result in unintended program flow.

Automated Detection

Related Vulnerabilities

Search for vulnerabilities resulting from the violation of this rule on the CERT website.

Related Guidelines

Bibliography