MISRA C++:2023 Rule 8.18.2

The result of an assignment operator should not be used

Since R2024b

Description

Rule Definition

The result of an assignment operator should not be used. ¹

Rationale

Using an assignment operation inside a larger expression can reduce the readability of the code.

In addition, when used in a subexpression, assignment operators have side effects that are difficult to track and might produce results contrary to developer expectations.

Polyspace Implementation

The rule checker reports a violation when an assignment operation is a subexpression inside a larger expression. The checker makes an exception for the case when the subexpression is unevaluated, for instance, inside a sizeof operator.

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

Avoid Using Assignment Operators in Sub-Expressions

#include <cstdint>

bool example(int x, int y)
{
	if (x == 10) 		//Compliant
	{
		return true;
	}
	
       if ((x = y) == 0)        //Noncompliant
	{
		return false;
	}
	
	return false;
}

Because the assignment operator = is used in the subexpression (x = y), Polyspace flags it as noncompliant.

Check Information

Group: Expressions

Category: Advisory

Version History

Introduced in R2024b

expand all

R2025a: Dynamic initialization of objects or initialization of object arrays no longer reported as violation

Polyspace no longer reports a violation when:

A class object is initialized dynamically using the new operator. For example:

class myClass {
public:
	myClass() {}
};

void foo() {
	myClass *ptr;
	ptr = new myClass;     // Not a violation
    //...
	delete ptr;
}

An element of an array of objects is initialized using an assignment. For example:

class  xvalue {
  public:
    xvalue& operator=(xvalue other) { 
      // Copy assignment operator body
    }
};
void foo(xvalue plhs[], xvalue xvalueResult)
{
    plhs[0] = xvalueResult;   // Not a violation
}