What does i = (i, ++i, 1) + 1; do?

Quoting from C11, chapter 6.5.17, Comma operator

The left operand of a comma operator is evaluated as a void expression; there is a sequence point between its evaluation and that of the right operand. Then the right operand is evaluated; the result has its type and value.

So, in your case,

(i, ++i, 1)

is evaluated as

1. i, gets evaluated as a void expression, value discarded
2. ++i, gets evaluated as a void expression, value discarded
3. finally, 1, value returned.

So, the final statement looks like

i = 1 + 1;

and i gets to 2. I guess this answers both of your questions,

• How i gets a value 2?
• Why there is a warning message?

Note: FWIW, as there is a sequence point present after the evaluation of the left hand operand, an expression like (i, ++i, 1) won't invoke UB, as one may generally think by mistake.

In the expression (i, ++i, 1), the comma used is the comma operator

the comma operator (represented by the token ,) is a binary operator that evaluates its first operand and discards the result, and then evaluates the second operand and returns this value (and type).

Because it discards its first operand, it is generally only useful where the first operand has desirable side effects. If the side effect to the first operand does not takes place, then the compiler may generate warning about the expression with no effect.

So, in the above expression, the leftmost i will be evaluated and its value will be discarded. Then ++i will be evaluated and will increment i by 1 and again the value of the expression ++i will be discarded, but the side effect to i is permanent. Then 1 will be evaluated and the value of the expression will be 1.

It is equivalent to

i;          // Evaluate i and discard its value. This has no effect.
++i;        // Evaluate i and increment it by 1 and discard the value of expression ++i
i = 1 + 1;  

Note that the above expression is perfectly valid and does not invoke undefined behavior because there is a sequence point between the evaluation of the left and right operands of the comma operator.

i = (i, ++i, 1) + 1;

Let's analyse it step by step.

(i,   // is evaluated but ignored, there are other expressions after comma
++i,  // i is updated but the resulting value is ignored too
1)    // this value is finally used
+ 1   // 1 is added to the previous value 1

So we obtain 2. And the final assignment now:

i = 2;

Whatever was in i before it's overwritten now.