The expression:

(expression1,  expression2)

Firstexpression1 is evaluated, thenexpression2 is evaluated, and the value ofexpression2 is returned for the whole expression.

I've seen used most inwhile 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);}

Thecomma operator will evaluate the left operand, discard the result and then evaluate the right operand and that will be the result. Theidiomatic use as noted in the link is when initializing the variables used in afor 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 manygreat uses of thecomma operator, although it is easy to abuse to generate code that is hard to read and maintain.

From thedraft C99 standard the grammar is as follows:

expression:  assignment-expression  expression , assignment-expression

andparagraph 2 says:

Theleft operand of a comma operator is evaluated as a void expression; there is a sequence point after its evaluation. Then theright operand is evaluated; the result has its type and value.⁹⁷⁾ 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 doesnot yield an lvalue.

which means you can not assign to the result of thecomma operator.

It is important to note that the comma operator has thelowest 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

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 ofexpr2 in a function call or assignment.

It is often seen infor 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 wereshorts orints 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'sCode Complete advising against even using comma operators in afor loop: for readability and maintainability, the loop should be controlled by only one variable, and the expressions in thefor line itself should only contain loop-control code, not other extra bits of initialisation or loop maintenance.

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.

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--)

Another use - complementary to the already mentioned - is a method to avoid braces in a single line if.

// this:if (anything) A = 1, B = 2;// or:if (anything)  A = 1, B = 2;// instead of:if (anything) { A = 1; B = 2; }// or:if (anything) {  A = 1; B = 2;}

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 awhile 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.)

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

Thei case is handled as explained by most answers. All expressions are evaluated in left-to-right order but only the last one is assigned toi. The result of the(expression )is1`.

Thej case follows different precedence rules since, has the lowest operator precedence. Because of those rules, the compiler seesassignment-expression, constant, constant .... The expressions are again evaluated in left-to-right order and their side-effects stay visible, therefore,j is5 as a result ofj = 5.

Interstingly,int j = 5,4,3,2,1; is not allowed by the language spec. Aninitializer expects anassignment-expression so a direct, operator is not allowed.

Hope this helps.

• c
• operators
• comma-operator