MISRA C:2012 Rule 14.2

A for loop shall be well-formed

Description

Rule Definition

A for loop shall be well-formed¹ .

Rationale

The for loop provides a flexible looping facility. You can perform other operations besides the loop counter initialization, termination, and increment in the control statement, and increment the loop counter anywhere inside the loop body. However, using a restricted loop format makes your code easier to review and to analyze.

Polyspace Implementation

A for loop consists of three expressions, a loop counter, a loop flag and a loop body. The last assigned variable of the first expression is considered the loop counter. The checker raises a violation if the components of the for loop shows these properties:

• First expression of the for loop —

  • Does not initialize the loop counter.

  • Has a side effect other than setting the value of loop counter.

• The second expression of the for loop —

  • Does not contains a comparison operation involving the loop counter.

  • Uses an object that is also used in the loop body.

  • Has a side effect.

• The third expression of the for loop —

  • Contains an operation other than incrementing or decrementing the loop counter (separated by a comma from the increment or decrement).

  • Uses an object that is also used in the loop body.

  • Has a side effect other than updating the loop counter.

• The loop counter —

  • Has a data type that is not an integer or a pointer type.

  • Is modified inside the loop body.

Polyspace^® does not raise a violation when the second expression includes a binary operation that involves the loop counter. Loops that uses more than one loop counter are reported as violations of the rule. If the loop counter is in a structure or class, updating the structure or class is considered updating the loop counter.

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

Altering the Loop Counter Inside the Loop

void foo(void){

    for(short index=0; index < 5; index++){  /* Non-compliant */
        index = index + 3;       /* Altering the loop counter */
    }
}

In this example, the loop counter index changes inside the for loop. It is hard to determine when the loop terminates.

Correction — Use break to Terminate Loop

One possible correction is to use a break statement to terminate the loop early.

In this correction, the loop body explicitly terminates the loop when a condition is true.

void foo(void) {
	for(short index = 0; (index < 5); index++) { /* Compliant */
		if((index % 4) == 0) {
			break;       /* allows early termination of loop */
		}
	}
}

for Loops With Empty Clauses

void foo(void){
    for(short index = 0; ; index++) {}   /* Non-compliant */

    for(short index = 0; index < 10;) {} /* Non-compliant */

    short index;
    for(; index < 10;) {}     /* Non-compliant */

    for(; index < 10; index++) {} /* Compliant */

    for(;;){}  
          /* Compliant - Exception all three clauses can be empty */
}

This example shows for loops definitions with a variety of missing clauses. To be compliant, initialize the first clause variable before the for loop (line 9). However, you cannot have a for loop without the second or third clause.

The one exception is a for loop with all three clauses empty, so as to allow for infinite loops.

Check Information

Group: Control Statement Expressions

Category: Required

AGC Category: Readability

Version History

R2025a: More formats of for loop reported as violation

Polyspace reports a violation for these additional cases:

• The first expression contains a side effect other than setting the value of the loop counter. For example, in this code, the first expression of the for loop sets a global variable:

   int globInt;
  int setGlobal(int num) {
  	globInt = num;
  	return globInt;
  }
  
  void foo(void) {
  	int i = 0 ;
  	for(setGLobal(0); i < 5; ++i) {
  		//...
  	}
  }

  This loop is now reported as a violation.

• The second expression uses an object that is used in the loop body. For example, the second expression in this loop uses the variable j which is also used in the loop body:

  volatile int getint();
  for(int i = 0; i < j; ++i) {
  	j = getint();
      //...
  }

• The second expression has a side effect.

• The third expression has a side effect other than updating the loop counter.

• The third expression uses an object that is used in the loop body.

• The loop uses as more than one loop counter.

The checker detects the side effects of the first expression more accurately and does not report a violation if the only side effect of the expression is setting the loop counter. If the loop counter is in a structure or class, updating the structure or class is considered updating the loop counter.

R2022a: Checker no longer flags use of binary operations in loop condition

The checker does not raise a flag if a for loop tests the condition by using a binary operation. For instance:

int i,b;
//...
for(i = 0; (i+b)<5;++i)//Compliant