Explain the output of the following C program?

Question

Please give a detail explanation of how (a+=3,5,a) is evaluated in the following program.

#include <stdio.h>
int main()
{
    int a=1,b=2,c=3;
    printf("%d\n",a+=(a+=3,5,a));
}

Answer 1

In the following code, b and c are evaluated and the last value is added to a and assigned to d.

#include <stdio.h>

int main(void)
{
    int a = 1, b = 2, c = 3, d;
    d = a + (b, c);
    printf("%d\n", d);
    return 0;
}

Program output: 4

But the expression in the question has undefined behaviour since a is being altered more than once without a sequence point.

Answer 2

The code under consideration is, when modernized and given some missing spaces:

#include <stdio.h>
int main(void)
{
    int a = 1, b = 2, c = 3;
    printf("%d\n", a += (a += 3, 5, a));
    return 0;
}

My initial reaction was "dup of Why are these constructs undefined behaviour", even though that is primarily about ++ and -- operators which are more often seen in such questions.

A second glance notes that there a comma operators in (a += 3, 5, a) and these impose sequence points. On its own, this much of the expression is fine. If it were used in b += (a += 3, 5, a), there would be no problem. The text of the question asks about just (a += 3, 5, a).

Of course, the , 5 does nothing useful. And when that's eliminated, the only reason to use (a += 3, a) is to put a sequence point between the addition and the a. However, there are no circumstances I can think of where you could legitimately need that sequence point.

The more complex issue is whether the evaluation of the LHS of a += (a += 3, 5, a) is properly sequenced with the RHS. It is undefined behaviour because although there are sequence points in the RHS expression, there isn't a sequence point between the evaluation of the LHS and RHS of the overall expression.

Remember that the compound assignment operator += behaves more or less as:

a += x;
a = a + x;

The difference is that the expression on the LHS (a in this example) is only evaluated once. In this case, there's no problem. If the code were more complex, this detail matters:

array[index++].member[subindex++] += 23;

Now it is crucial that the LHS is only evaluated once!

Summary

The code in the question is tricky code and, because it has undefined behaviour, it should be avoided in production code.

I wonder why b and c are in the question at all; they're unused variables. So much confusion in so little code!

---

Rule of thumb: Avoid multiple increments, decrements and compound assignment operators in a single expression.

Advanced rule of thumb (for experts only): don't apply multiple increments, decrements or compound assignment operators to the same variable in a single expression.

If you know enough to know when you can safely break the rules (?:), then you don't necessarily need to follow the rules of thumb. Until then, avoid over-using these operators.

Answer 3

Execution of printf in c is from right to left.

(a+=3,5,a), makes a=4
Then a+=(a+=3,5,a) add the last value i.e a to a
Thatswhy a becomes 8.

Answer 4

Here (a+=3,5,a) gives the output 4 because anything you put after a+=3 does not considered by the value a. for ex: int a=1; a+=2,8,5;

Here value of a=3; since a+=2 is 3.

And after that a+=(a+=3,5,a) evaluates like this.

Here assignment operator always assign right most value to the left operand. so here a is assigned. so this leads to a+=a; therefore the value is 8. since value of a=4; after (a+=3,5,a) operation.

I will give another example int a=2; a+=(a+=2,2,a,10)

will give output as 14. since value of a=4 after (a+=2,2,a,10) operation. and 10 is assigned in right i.e a+=10; this will give us 14.

I hope your question has answered. if you have doubt comment below.