Please explain the output of following C code

Question

Code :

#include<stdio.h>
#include<stdlib.h>

int arr[] = {1, 2, 3, 4};
static int count = 0;

int incr( ) {
    ++count;
    ++count;
    return count;
}

int main(void)
{ 
    printf("\ncount= %d \n",count);
    int i;
    arr[count++]=incr( );
    for(i=0;i<4;i++)
       printf("arr[%d]=%d\n", i,arr[i]);
    printf("\nIncremented count= %d \n",count);
    return 0;
}

Output

count = 0  
arr[0]=2  
arr[1]=2  
arr[2]=3  
arr[3]=4  
Incremented count = 1  

The final incremented value of global variable count is 1 even though it has been incremented thrice.

When count++ is replaced by count in arr[count++]=incr( ) the final incremented value of count is 2.

Answer 1

This is undefined behaviour from bad sequencing. On this line:

arr[count++]=incr( );

What happens (with your compiler) is:

• arr[count] is resolved to arr[0], postfix ++ will be applied at the end of the statement;
• incr() is called, count is now equal to 2, incr() returns 2;
• arr[0] gets assigned 2;
• postfix ++'s side effect kicks in, and count is now equal to 1. Previous changes to count are lost.

You will find more info on "side effects" and "sequence points" by googling their real name :)

Answer 2

To understand why your code goes wrong, you must first understand undefined behavior and sequence points, which is a rather advanced topic. You also need to understand what undefined behavior is, and what unspecified behavior is, explained here.

If you do something to a variable which counts as a side-effect, such as modifying it, then you are not allowed to access that variable again before the next sequence point, for other purposes than to calculate which value to store in your variable.

For example i = i++ is undefined behavior because there are two side effects on the same variable with no sequence point in between. But i = i+1; is well-defined, because there is only one side effect (the assignment) and the i+1 is only a read access to determine what value to store.

In your case, there is no sequence point between the arr[count++] sub-expression and the incr() sub-expression, so you get undefined behavior.

This is how sequence points appear in functions, C11 6.5.2.2:

There is a sequence point after the evaluations of the function designator and the actual arguments but before the actual call. Every evaluation in the calling function (including other function calls) that is not otherwise specifically sequenced before or after the execution of the body of the called function is indeterminately sequenced with respect to the execution of the called function.

This means that the contents of the function aren't sequenced in relation to the rest of the expression. So you are essentially writing an expression identical to arr[count++] = ++count;, except through the function you managed to squeeze in two unsequenced ++count on the right side of the operation, which wouldn't otherwise be possible. Any any rate, it is undefined behavior.

Fix your code by enforcing sequence points between the left hand and the right hand of the expression. However, the order of evaluation of sub-expressions is unspecified behavior, so you need to ensure that your code is safe no matter if the left or right side is evaluated first. This code will fix the problems:

// artificial example, don't write code like this
0,arr[count++] = 0,incr();

since the comma operator introduces a sequence point. But of course, writing nonsense code like that isn't something you should be doing. The real solution is to never use ++ together with other operators in the same expression.

// good code, write code like this
arr[count] = incr();
count++;