MISRA C:2012 Rule 13.3

A full expression containing an increment (++) or decrement (--) operator should have no other potential side effects other than that caused by the increment or decrement operator

Description

Rule Definition

A full expression containing an increment (++) or decrement (--) operator should have no other potential side effects other than that caused by the increment or decrement operator¹ .

Rationale

The rule is violated if the following happens in the same line of code:

• The increment or decrement operator acts on a variable.

• Another read or write operation is performed on the variable.

For example, the line y=x++ violates this rule. The ++ and = operator both act on x.

Although the operator precedence rules determine the order of evaluation, placing the ++ and another operator in the same line can reduce the readability of the code.

Troubleshooting

If you expect a rule violation but do not see it, refer to Diagnose Why Coding Standard Violations Do Not Appear as Expected.

Examples

Increment Operator Used in Expression with Other Side Effects

int input(void);
int choice(void);
int operation(int, int);

int func() {
    int x = input(), y = input(), res;
    int ch = choice();
    if (choice == -1)
        return(x++);               // Noncompliant
    if (choice == 0) {
        res = x++ + y++;           // Noncompliant
        return(res);
    }
    else if (choice == 1) {
        x++;                       // Compliant
        y++;                       // Compliant
        return (x+y);
    }
    else {
        res = operation(x++,y);    // Noncompliant
        return(res);
    }
}

In this example, the rule is violated when the expressions containing the ++ operator have side effects other than that caused by the operator. For example, in the expression return(x++), the other side-effect is the return operation.

Check Information

Group: Side Effects

Category: Advisory

AGC Category: Readability

Version History

Introduced in R2014b

R2024b: Polyspace reports violation on macro use

If you use a macro in a way that causes side effects, Polyspace flags the use of the macro, not the macro definition. Polyspace^® no longer reports a violation on the macro definition as the definition itself is not a violation of this rule.

R2024a: Violations no longer reported on *p++

Starting in R2024a, Polyspace no longer reports a rule violation on *p++ because the only side effect is a result of the increment operator.

++(*p);        // Compliant
*p++;          // Compliant
(*p)++;        // Compliant