Do not use the assignment operator in the following contexts because it typically indicates programmer error and can result in unexpected behavior:
Operator | Context |
---|---|
if | controlling expression |
while | controlling expression |
do ... while | controlling expression |
for | second operand |
?: | first operand |
?: | second or third operands, where the ternary expression is used in any of these contexts |
&& | either operand |
|| | either operand |
, operator | second operand, when the comma expression is used in any of these contexts |
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 very 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.
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) { /* ... */ } |
When the assignment is intended, the following is an alternative compliant solution:
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.
In this noncompliant example, the expression x = y
is used as the controlling expression of the while
statement:
do { /* ... */ } while (foo(), x = y); |
When the assignment of y to x is not intended, this conditional block is now executed when x is equal to y:
do { /* ... */ } while (foo(), x == y); |
When the assignment is intended, the following is an alternative compliant solution:
do { /* ... */ } while (foo(), (x = y) != 0); |
In this noncompliant example, the expression p = q
is used as the controlling expression of the while
statement:
do { /* ... */ } while (x = y, p = q); |
This is a compliant example because the expression x = y
is not used as the controlling expression of the while
statement:
do { /* ... */ } while (x = y, p == q); |
EXP45-EX1: Assignment can be used where the result of the assignment is itself a parameter to a comparison expression or relational expression. In this compliant example, the expression x = y
is itself a parameter to a comparison operation:
if ((x = y) != 0) { /* ... */ } |
EXP45-EX2: Assignment can be used where the expression consists of a single primary expression. In this compliant example, the expression x = y
is a single primary expression:
if ((x = y)) { /* ... */ } |
EXP45-EX3: Assignment can be used in the above contexts if it occurs in a function argument or array index. In this compliant example, the expression x = y
is used in a function argument:
if (foo(x = y)) { /* ... */ } |
This is a noncompliant example 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, this conditional block is now executed when v
is equal to w
:
if ((v == w) && flag) { /* ... */ }; |
When the assignment is intended, the following is an alternative compliant solution:
if (((v = w) != 0) && flag) { /* ... */ }; |
Errors of omission can result in unintended program flow.
Recommendation | Severity | Likelihood | Remediation Cost | Priority | Level |
---|---|---|---|---|---|
EXP45-C | Low | Likely | Medium | P6 | L2 |
Tool | Version | Checker | Description |
---|---|---|---|
|
| Could detect violations of this recommendation by identifying any assignment expression as the top-level expression in an | |
CC2.EXP18 | Fully implemented | ||
| Can detect violations of this recommendation when the | ||
ASSIGCOND.GEN |
| ||
9 S |
| ||
PRQA QA-C | 3314 | Partially implemented |
Search for vulnerabilities resulting from the violation of this rule on the CERT website.
CERT C++ Secure Coding Standard | EXP19-CPP. Do not perform assignments in conditional expressions |
CERT Oracle Secure Coding Standard for Java | 53. Do not perform assignments in conditional expressions |
ISO/IEC TR 24772:2013 | Likely Incorrect Expression [KOA] |
ISO/IEC TS 17961 | No assignment in conditional expressions [boolasgn] |
MITRE CWE | CWE-480, Use of incorrect operator |
[Hatton 1995] | Section 2.7.2, "Errors of Omission and Addition" |