MISRA C++:2023 Rule 8.19.1

The comma operator should not be used

Since R2024b

Description

Rule Definition

The comma operator should not be used.

Rationale

The comma operator takes two operands. It evaluates the operators from left to right, discards the value of the left operand,and returns the value of the right operand. This operator has the lowest operator precedence. These properties make the use of the comma operator nonintuitive. For instance, consider this code:

array[i++,j] = 1

At a glance, it might appear that the preceding code accesses a multidimensional array. In fact, this code is equivalent to:

i++;
array[j] = 1;

The use of the comma operator makes the code difficult to read and maintain. To avoid confusion, do not use the comma operator. Refactor the expression into multiple statements instead.

Polyspace Implementation

Polyspace^® flags the use of comma operator. Violations are not raised when you use comma operator for function calls or initializations, or when you use a comma as the fold operator within a fold expression.

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

Comma Usage in C++ Code

typedef signed int abc, xyz, jkl;
static void func1 ( abc, xyz, jkl );       //Compliant - case 1 
int foo(void)
{
    volatile int rd = 1;					//Compliant - case 2
    int var=0, foo=0, k=0, n=2, p, t[10];	//Compliant - case 3
    int abc = 0, xyz = abc + 1;				//Compliant - case 4
    int jkl = ( abc + xyz, abc + xyz );		//Noncompliant - case 1
    var = 1, foo += var, n = 3;				//Noncompliant - case 2 
    var = (n = 1, foo = 2);					//Noncompliant - case 3
    for ( int *ptr = &t[ 0 ],var = 0 ;
          var < n; ++var, ++ptr){}    		//Noncompliant - case 4
    if ((abc,xyz)<0) { return 1; }			// Noncompliant - case 5
}

In this example, the code shows various uses of commas in C code.

Noncompliant Cases

Case	Reason for noncompliance
1	When reading the code, it is not immediately obvious what `jkl` is initialized to. For example, you could infer that `jkl` has a value `abc+xyz`, `(abc+xyz)*(abc+xyz)`, `f((abc+xyz),(abc+xyz))`, and so on.
2	When reading the code, it is not immediately obvious whether `foo` has a value 0 or 1 after the statement.
3	When reading the code, it is not immediately obvious what value is assigned to `var`.
4	When reading the code, it is not immediately obvious which values control the `for` loop.
5	When reading the code, it is not immediately obvious whether the `if` statement depends on `abc`, `xyz`, or both.

Compliant Cases

Case	Reason for compliance
1	Using commas to call functions with variables is allowed.
2	Comma operator is not used.
3 & 4	When using the comma for initialization, the variables and their values are immediately obvious.

Check Information

Group: Expressions

Category: Advisory

Version History

Introduced in R2024b