Main Content

MISRA C++:2023 Rule 8.14.1

The right-hand operand of a logical && or || operator should not contain persistent side effects

Since R2024b

expand all in page

Description

Rule Definition

The right-hand operand of a logical && or || operator should not contain persistent side effects.

Rationale

The right operand of the || operator is not evaluated if the left operand is true. The right operand of the && operator is not evaluated if the left operand is false. In these cases, if the right operand modifies the value of a variable, the modification does not take place.

Polyspace Implementation

The rule checker reports situations where the right operand of a logical || or && operator has persistent side effects. For example, if the right operand contains a function call and the function modifies a global variable, the rule checker reports a violation.

The rule checker does not report a violation if the right operand contains a call to a pure function, that is, a function without side effects. The checker considers a function as pure if the function performs only simple operations such as:

  • Reading a nonvolatile parameter or global variable.

  • Writing to a local variable.

In addition to simple operations, if the function contains a call to another function, the checker attempts to determine if the called function is a pure function. If the called function is a pure function, the checker propagates this information and tags the calling function as a pure function (as long as the other operations in the calling function are simple operations).

The rule checker does not consider a function as pure if the function does any of these:

  • Writes to a global variable or dereferences a parameter

  • Reads or writes to a volatile variable, or contains an asm block

To determine if a function is pure, the checker needs to analyze the function definition. The checker looks for function definitions only within the same translation unit as the function call. A translation unit is a source file plus all headers included in the source. If a function definition is not found in the current translation unit, the checker does not report a violation of this rule.

Troubleshooting

If you expect a rule violation but Polyspace® does not report it, see Diagnose Why Coding Standard Violations Do Not Appear as Expected.

Examples

expand all

int check (int arg) {
    static int count;
    if(arg > 0) {
        count++;                   /* Persistent side effect */
        return 1;
    }
    else
        return 0;
}

int getSwitch(void);
int getVal(void);

void main(void) {
    int val = getVal();
    int mySwitch = getSwitch();
    int checkResult;

    if(mySwitch && check(val)) {   /* Noncompliant */
    }

    checkResult = check(val);
    if(checkResult && mySwitch) {  /* Compliant */
    }
    
    if(check(val) && mySwitch) {   /* Compliant */
    }
}

In this example, the rule is violated when the right operand of the && operator contains a call tot he function check(). The function call has a persistent side effect because check() modifies the static variable count. Depending on the value of mySwitch, this modification might or might not happen.

The rule is not violated when the left operand contains a function call. Alternatively, to avoid the rule violation, assign the result of the function call to a variable. Use this variable in the logical operation in place of the function call.

Check Information

Group: Expressions
Category: Advisory

Version History

Introduced in R2024b

See Also

Topics