175

After reading this answer about undefined behavior and sequence points, I wrote a small program:

#include <stdio.h>

int main(void) {
  int i = 5;
  i = (i, ++i, 1) + 1;
  printf("%d\n", i);
  return 0;
}

The output is 2. Oh God, I didn't see the decrement coming! What is happening here?

Also, while compiling the above code, I got a warning saying:

px.c:5:8: warning: left-hand operand of comma expression has no effect

  [-Wunused-value]   i = (i, ++i, 1) + 1;
                        ^

Why? But probably it will be automatically answered by the answer of my first question.

27
  • 293
    Don't do weird things, you'll have no friends :(
    – Maroun
    Commented Jun 3, 2015 at 8:15
  • 9
    The warning message is the answer to your first question.
    – Yu Hao
    Commented Jun 3, 2015 at 8:17
  • 2
    @gsamaras: nope. the resulting value is discarded, not the modification. the real answer: the comma operator creates a sequence point. Commented Jun 3, 2015 at 8:36
  • 3
    @gsamaras You shouldn't care when you have positive score and even more with 10+ question. Commented Jun 3, 2015 at 16:43
  • 9
    Note: An optimizing compiler may simple do printf("2\n");
    – chux
    Commented Jun 3, 2015 at 17:27

7 Answers 7

256

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.

5
  • 1
    although the final expression is valid, isn't the second expression ++i an undefined behaviour ? it is evaluated and the value of uninitialized variable is pre-incremented, which is not right? or am i missing something? Commented Jun 4, 2015 at 5:59
  • 2
    @Koushik; i is initialized with 5. Look at the declaration statement int i = 5;.
    – haccks
    Commented Jun 4, 2015 at 6:42
  • 1
    oh my bad. Sorry i honestly dint see that. Commented Jun 4, 2015 at 6:43
  • There is a mistake here: ++i will increment i then evaluate it, while i++ will evaluate i then increment it. Commented Jun 4, 2015 at 14:54
  • 1
    @QuentinHayot; What? Any side effects takes place after the evaluation of expression. In case of ++i, this expression will be evaluated, i will be incremented and this incremented value will be the value of the expression. In case of i++, this expression will be evaluated, the old value of i will be the value of the expression, i will be incremented at any time between the previous and the next sequence point of the expression.
    – haccks
    Commented Jun 4, 2015 at 16:35
62

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.

2
  • +1 Sourav, since this explains why the intialization of i clearly has no effect! However, I do not think it was so obvious for a guy that does not know the comma operator (and I did not know how to search for help, other than asking a question). Pity I got so many downvotes! I'll check the other answers and then decide which to accept. Thanks! Nice top answer btw.
    – gsamaras
    Commented Jun 3, 2015 at 8:22
  • I feel I have to explain why I accepted haccks answer. I was ready to accept yours, since it's really answers my both questions. However, if you check the comments of my question, you'll see that some people can't see at first glance why this does not invoke UB. haccks answers provide some relevant info. Of course, I have the answer regarding UB linked in my question, but some people may miss that. Hope you agree with my desicion, if not let me know. :)
    – gsamaras
    Commented Jun 3, 2015 at 9:12
30
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.

3
  • It would be nice to state that this happens because of the comma operator. +1 for the step by step analysis though! Nice top answer btw.
    – gsamaras
    Commented Jun 3, 2015 at 8:30
  • I am sorry for insufficient explanation, I have only a note there (...but ignored, there are...). I wanted to explain mainly why the ++i doesn't contribute to the result.
    – dlask
    Commented Jun 3, 2015 at 8:37
  • now my for loops will be always like int i = 0; for( ;(++i, i<max); ) Commented Jun 4, 2015 at 18:36
19

The outcome of

(i, ++i, 1)

is

1

For

(i,++i,1) 

the evaluation happens such that the , operator discards the evaluated value and will retain just the right most value which is 1

So

i = 1 + 1 = 2
2
  • 1
    Yeah I thought of that too, but I do not know why!
    – gsamaras
    Commented Jun 3, 2015 at 8:15
  • @gsamaras because the comma operator evaluates the previous term but discards it (i.e. doesn't use it for assignments or the like)
    – Marco A.
    Commented Jun 3, 2015 at 8:17
14

You'll find some good reading on the wiki page for the Comma operator.

Basically, it

... evaluates its first operand and discards the result, and then evaluates the second operand and returns this value (and type).

This means that

(i, i++, 1)

will, in turn, evaluate i, discard the result, evaluate i++, discard the result, and then evaluate and return 1.

1
  • O_O hell, does that syntax is valid in C++, I remember I had few places where I needed that syntax (basically I wrote : (void)exp; a= exp2; while I just needed a = exp, exp2;) Commented Jun 4, 2015 at 18:32
13

You need to know what the comma operator is doing here:

Your expression:

(i, ++i, 1)

The first expression, i, is evaluated, the second expression, ++i, is evaluated, and the third expression, 1, is returned for the whole expression.

So the result is: i = 1 + 1.

For your bonus question, as you see, the first expression i has no effect at all, so the compiler complains.

0
5

Comma has an 'inverse' precedence. This is what you will get from old books and C manuals from IBM (70s/80s). So the last 'command' is what is used in parent expression.

In modern C its use is strange but is very interesting in old C (ANSI):

do { 
    /* bla bla bla, consider conditional flow with several continue's */
} while ( prepAnything(), doSomethingElse(), logic_operation);

While all operations (functions) are called from left to right, only the last expression will be used as a result to conditional 'while'. This prevent handling of 'goto's to keep a unique block of commands to run before condition check.

EDIT: This avoid also a call to a handling function which could take care of all logic at left operands and so return the logical result. Remember that, we had not inline function in the past of C. So, this could avoid a call overhead.

2
  • Luciano, you got also link to this answer: stackoverflow.com/questions/17902992/….
    – gsamaras
    Commented Jun 11, 2015 at 13:37
  • In the early 90s before of inline functions, I used it a lot to optimize and keep code organized.
    – Luciano
    Commented Jun 11, 2015 at 13:53

Not the answer you're looking for? Browse other questions tagged or ask your own question.