CERT C: Rec. EXP10-C

Do not depend on the order of evaluation of subexpressions or the order in which side effects take place

Description

Rule Definition

Do not depend on the order of evaluation of subexpressions or the order in which side effects take place.¹

Polyspace Implementation

The rule checker checks for Expression value depends on order of evaluation or of side effects.

Examples

Expression value depends on order of evaluation or of side effects

Issue

The issue occurs when the value of an expression and its persistent side effects is not the same under all permitted evaluation orders.

An expression can have different values under the following conditions:

• The same variable is modified more than once in the expression, or is both read and written.

• The expression allows more than one order of evaluation.

Therefore, this rule forbids expressions where a variable is modified more than once and can cause different results under different orders of evaluation.

Risk

If an expression results in different values depending on the order of evaluation, its value becomes implementation-defined.

Example — Variable Modified More Than Once in Expression

int a[10], b[10];
#define COPY_ELEMENT(index) (a[(index)]=b[(index)])

void main () {
    int i=0, k=0;

    COPY_ELEMENT (k);         /* Compliant */
    COPY_ELEMENT (i++);       /* Noncompliant  */
}

In this example, the rule is violated by the statement COPY_ELEMENT(i++) because i++ occurs twice and the order of evaluation of the two expressions is unspecified.

Example — Variable Modified and Used in Multiple Function Arguments

void f (unsigned int param1, unsigned int param2) {}

void main () {
    unsigned int i=0;
    f ( i++, i );                 /* Non-compliant */
}

In this example, the rule is violated because it is unspecified whether the operation i++ occurs before or after the second argument is passed to f. The call f(i++,i) can translate to either f(0,0) or f(0,1).

Check Information

Group: Rec. 03. Expressions (EXP)

Version History

Introduced in R2019a

R2023b: Correctly sequenced double writes no longer reported as violation

The rule checker does not report violations of this rule when you use correctly sequenced double writes:

i=i=0; //Compliant
j = j = ++j;//Compliant

R2021b: Checker reports violation when global variable is written and reused in same expression

The checker shows more accurate results. For instance:

• The checker reports only one violation when a variable is written and reused within the same expression. Previously, two violations were reported.

• The checker detects violations involving global variables, for instance, when the same global variable is written and reused in an expression.