What does the ,
operator do in C?
-
possible duplicate of [What is the proper use of the comma operator?](http://stackoverflow.com/questions/17902992/what-is-the-proper-use-of-the-comma-operator) – Sergey K. Aug 28 '13 at 08:00
-
1As I note in my answer, there is a sequence point after the evaluation of the left operand. This is unlike the comma in a function call which is just grammatical. – Shafik Yaghmour Jun 25 '14 at 11:46
-
3@SergeyK. — Given that this was asked and answered years before the other, it is more likely that the other is a duplicate of this question. However, the other is also dual-tagged with both [tag:c] and [tag:c++], which is a nuisance. This is a C-only Q&A, with decent answers. – Jonathan Leffler May 18 '19 at 00:18
8 Answers
The expression:
(expression1, expression2)
First expression1
is evaluated, then expression2
is evaluated, and the value of expression2
is returned for the whole expression.
-
5then if I write i = (5,4,3,2,1,0) then ideally it should return 0, correct? but i is being assigned a value of 5? Can you please help me understand where am I going wrong? – Jayesh Nov 13 '10 at 06:55
-
25@James: The value of a comma operation will always be the value of the last expression. At no point will `i` have the values 5, 4, 3, 2 or 1. It is simply 0. It's practically useless unless the expressions have side effects. – Jeff Mercado Nov 13 '10 at 07:06
-
7Note that there is a full sequence point between the evaluation of the LHS of the comma expression and the evaluation of the RHS (see [Shafik Yaghmour](http://stackoverflow.com/users/1708801/shafik-yaghmour)'s [answer](http://stackoverflow.com/a/18444099/15168) for a quote from the C99 standard). This is an important property of the comma operator. – Jonathan Leffler Jun 20 '14 at 20:47
-
Looking at https://learn.microsoft.com/en-us/cpp/cpp/comma-operator, there seems to be a difference if parenthesis is not used. In case of i = b, c; b gets assigned to i. How this is happening? In case of function parameter, parenthesis usage is a must and Microsoft clearly explains this. – Rajesh Apr 26 '18 at 04:25
-
9`i = b, c;` is equivalent to `(i = b), c` because because assignment `=` has higher precedence than the comma operator `,`. The comma operator has the lowest precedence of all. – cyclaminist Feb 02 '19 at 06:10
-
1I worry that the parentheses are misleading on two counts: (1) they're not necessary — the comma operator doesn't have to be surrounded by parentheses; and (2) they could be confused with the parentheses around the argument list of a function call — but the comma in the argument list is not the comma operator. However, fixing it is not entirely trivial. Maybe: _In the statement: `expression1, expression2;` first `expression1` is evaluated, presumably for its side-effects (such as calling a function), then there is a sequence point, then `expression2` is evaluated and the value returned…_ – Jonathan Leffler May 18 '19 at 00:22
I've seen used most in while
loops:
string s;
while(read_string(s), s.len() > 5)
{
//do something
}
It will do the operation, then do a test based on a side-effect. The other way would be to do it like this:
string s;
read_string(s);
while(s.len() > 5)
{
//do something
read_string(s);
}
-
28Hey, that's nifty! I've often had to do unorthodox things in a loop to fix that problem. – staticsan Sep 04 '09 at 01:47
-
6Although it'd probably be less obscure and more readable if you did something like: `while (read_string(s) && s.len() > 5)`. Obviously that wouldn't work if `read_string` doesn't have a return value (or doesn't have a meaningful one). (Edit: Sorry, didn't notice how old this post was.) – jamesdlin Mar 25 '10 at 08:05
-
15@staticsan Don't be afraid to use `while (1)` with a `break;` statement in the body. Trying to force the break-out part of the code up into the while test or down into the do-while test, is often a waste of energy and makes the code harder to understand. – potrzebie Sep 27 '12 at 06:20
-
9@jamesdlin ... and people still read it. If you have something useful to say, then say it. Forums have problems with resurrected threads because threads are usually sorted by date of last post. StackOverflow doesn't have such problems. – Dimitar Slavchev Nov 29 '12 at 13:36
-
4@potrzebie I like the comma approach much better than `while(1)` and `break`; – Michael Mar 11 '16 at 14:19
-
3Yes, this is an excellent piece of DRY* and justification for a rarely used operator. (*to which the 2nd example is highly offensive!) – underscore_d Apr 16 '16 at 21:43
-
1It also nicely separates the code into "setup and checks" and "do stuff" which IMO improves readability. Especially since the `read_string(s)` in the body of the `while` statement, has no fixed position in principle, or might even change positions from revision to revision. – NOhs Jun 20 '19 at 13:01
-
1Note that this is not valid C code, since the questions is asked for C. – RobertS supports Monica Cellio Feb 19 '20 at 16:05
-
This can be made more compact with a `for` loop, additionally tightening the scope of `s`: `for (string s; read_string(s), s.len() > 5;) { Something(); }` – tobi_s Aug 08 '23 at 06:56
The comma operator will evaluate the left operand, discard the result and then evaluate the right operand and that will be the result. The idiomatic use as noted in the link is when initializing the variables used in a for
loop, and it gives the following example:
void rev(char *s, size_t len)
{
char *first;
for ( first = s, s += len - 1; s >= first; --s)
/*^^^^^^^^^^^^^^^^^^^^^^^*/
putchar(*s);
}
Otherwise there are not many great uses of the comma operator, although it is easy to abuse to generate code that is hard to read and maintain.
From the draft C99 standard the grammar is as follows:
expression:
assignment-expression
expression , assignment-expression
and paragraph 2 says:
The left operand of a comma operator is evaluated as a void expression; there is a sequence point after its evaluation. Then the right operand is evaluated; the result has its type and value. 97) If an attempt is made to modify the result of a comma operator or to access it after the next sequence point, the behavior is undefined.
Footnote 97 says:
A comma operator does not yield an lvalue.
which means you can not assign to the result of the comma operator.
It is important to note that the comma operator has the lowest precedence and therefore there are cases where using ()
can make a big difference, for example:
#include <stdio.h>
int main()
{
int x, y ;
x = 1, 2 ;
y = (3,4) ;
printf( "%d %d\n", x, y ) ;
}
will have the following output:
1 4

- 1
- 1

- 154,301
- 39
- 440
- 740
The comma operator combines the two expressions either side of it into one, evaluating them both in left-to-right order. The value of the right-hand side is returned as the value of the whole expression.
(expr1, expr2)
is like { expr1; expr2; }
but you can use the result of expr2
in a function call or assignment.
It is often seen in for
loops to initialise or maintain multiple variables like this:
for (low = 0, high = MAXSIZE; low < high; low = newlow, high = newhigh)
{
/* do something with low and high and put new values
in newlow and newhigh */
}
Apart from this, I've only used it "in anger" in one other case, when wrapping up two operations that should always go together in a macro. We had code that copied various binary values into a byte buffer for sending on a network, and a pointer maintained where we had got up to:
unsigned char outbuff[BUFFSIZE];
unsigned char *ptr = outbuff;
*ptr++ = first_byte_value;
*ptr++ = second_byte_value;
send_buff(outbuff, (int)(ptr - outbuff));
Where the values were short
s or int
s we did this:
*((short *)ptr)++ = short_value;
*((int *)ptr)++ = int_value;
Later we read that this was not really valid C, because (short *)ptr
is no longer an l-value and can't be incremented, although our compiler at the time didn't mind. To fix this, we split the expression in two:
*(short *)ptr = short_value;
ptr += sizeof(short);
However, this approach relied on all developers remembering to put both statements in all the time. We wanted a function where you could pass in the output pointer, the value and and the value's type. This being C, not C++ with templates, we couldn't have a function take an arbitrary type, so we settled on a macro:
#define ASSIGN_INCR(p, val, type) ((*((type) *)(p) = (val)), (p) += sizeof(type))
By using the comma operator we were able to use this in expressions or as statements as we wished:
if (need_to_output_short)
ASSIGN_INCR(ptr, short_value, short);
latest_pos = ASSIGN_INCR(ptr, int_value, int);
send_buff(outbuff, (int)(ASSIGN_INCR(ptr, last_value, int) - outbuff));
I'm not suggesting any of these examples are good style! Indeed, I seem to remember Steve McConnell's Code Complete advising against even using comma operators in a for
loop: for readability and maintainability, the loop should be controlled by only one variable, and the expressions in the for
line itself should only contain loop-control code, not other extra bits of initialisation or loop maintenance.

- 1,210
- 2
- 11
- 24

- 67,682
- 9
- 49
- 51
It causes the evaluation of multiple statements, but uses only the last one as a resulting value (rvalue, I think).
So...
int f() { return 7; }
int g() { return 8; }
int x = (printf("assigning x"), f(), g() );
should result in x being set to 8.

- 20,538
- 18
- 127
- 187
-
It does. And it is set to 11 if you leave out the outer braces. Quite interesting and definitely worth a compiler warning for some cases. – sebkraemer Oct 12 '20 at 10:57
As earlier answers have stated it evaluates all statements but uses the last one as the value of the expression. Personally I've only found it useful in loop expressions:
for (tmp=0, i = MAX; i > 0; i--)

- 16,111
- 8
- 50
- 66
The only place I've seen it being useful is when you write a funky loop where you want to do multiple things in one of the expressions (probably the init expression or loop expression. Something like:
bool arraysAreMirrored(int a1[], int a2[], size_t size)
{
size_t i1, i2;
for(i1 = 0, i2 = size - 1; i1 < size; i1++, i2--)
{
if(a1[i1] != a2[i2])
{
return false;
}
}
return true;
}
Pardon me if there are any syntax errors or if I mixed in anything that's not strict C. I'm not arguing that the , operator is good form, but that's what you could use it for. In the case above I'd probably use a while
loop instead so the multiple expressions on init and loop would be more obvious. (And I'd initialize i1 and i2 inline instead of declaring and then initializing.... blah blah blah.)

- 7,494
- 10
- 42
- 52
I'm reviving this simply to address questions from @Rajesh and @JeffMercado which i think are very important since this is one of the top search engine hits.
Take the following snippet of code for example
int i = (5,4,3,2,1);
int j;
j = 5,4,3,2,1;
printf("%d %d\n", i , j);
It will print
1 5
The i
case is handled as explained by most answers. All expressions are evaluated in left-to-right order but only the last one is assigned to i
. The result of the (
expression )is
1`.
The j
case follows different precedence rules since ,
has the lowest operator precedence. Because of those rules, the compiler sees assignment-expression, constant, constant .... The expressions are again evaluated in left-to-right order and their side-effects stay visible, therefore, j
is 5
as a result of j = 5
.
Interstingly, int j = 5,4,3,2,1;
is not allowed by the language spec. An initializer expects an assignment-expression so a direct ,
operator is not allowed.
Hope this helps.

- 114
- 1
- 8