What is the proper use of the comma operator?

Question

I saw this code:

if (cond) {
    perror("an error occurred"), exit(1);
}

Why would you do that? Why not just:

if (cond) {
    perror("an error occurred");
    exit(1);
}

Answer 1

In your example it serves no reason at all. It is on occasion useful when written as

if(cond)
  perror("an error occured"), exit(1) ;

-- then you don't need curly braces. But it's an invitation to disaster.

The comma operator is to put two or more expressions in a position where the reference only allows one. In your case, there is no need to use it; in other cases, such as in a while loop, it may be useful:

while (a = b, c < d)
  ...

where the actual "evaluation" of the while loop is governed solely on the last expression.

Answer 2

Legitimate cases of the comma operator are rare, but they do exist. One example is when you want to have something happen inside of a conditional evaluation. For instance:

std::wstring example;
auto it = example.begin();
while (it = std::find(it, example.end(), L'\\'), it != example.end())
{
    // Do something to each backslash in `example`
}

It can also be used in places where you can only place a single expression, but want two things to happen. For instance, the following loop increments x and decrements y in the for loop's third component:

int x = 0;
int y = some_number;
for(; x < y; ++x, --y)
{
    // Do something which uses a converging x and y
}

Don't go looking for uses of it, but if it is appropriate, don't be afraid to use it, and don't be thrown for a loop if you see someone else using it. If you have two things which have no reason not to be separate statements, make them separate statements instead of using the comma operator.

Answer 3

The main use of the comma operator is obfuscation; it permits doing two things where the reader only expects one. One of the most frequent uses—adding side effects to a condition, falls under this category. There are a few cases which might be considered valid, however:

The one which was used to present it in K&R: incrementing two variables in a for loop. In modern code, this might occur in a function like std::transform, or std::copy, where an output iterator is incremented symultaneously with the input iterator. (More often, of course, these functions will contain a while loop, with the incrementations in separate statements at the end of the loop. In such cases, there's no point in using a comma rather than two statements.)

Another case which comes to mind is data validation of input parameters in an initializer list:

MyClass::MyClass( T const& param )
    : member( (validate( param ), param) )
{
}

(This assumes that validate( param ) will throw an exception if something is wrong.) This use isn't particularly attractive, especially as it needs the extra parentheses, but there aren't many alternatives.

Finally, I've sometimes seen the convention:

ScopedLock( myMutex ), protectedFunction();

, which avoids having to invent a name for the ScopedLock. To tell the truth, I don't like it, but I have seen it used, and the alternative of adding extra braces to ensure that the ScopedLock is immediately destructed isn't very pretty either.

Answer 4

This can be better understood by taking some examples:

First: Consider an expression:

   x = ++j;

But for time being, if we need to assign a temporarily debug value, then we can write.

   x = DEBUG_VALUE, ++j; 

Second:
Comma , operators are frequently used in for() -loop e.g.:

for(i = 0, j = 10; i < N; j--, i++) 
 //      ^                   ^     here we can't use ;  

Third:
One more example(actually one may find doing this interesting):

if (x = 16 / 4), if remainder is zero then print  x = x - 1;  
if (x = 16 / 5), if remainder is zero then print  x = x + 1;

It can also be done in a single step;

  if(x = n / d, n % d) // == x = n / d; if(n % d)
    printf("Remainder not zero, x + 1 = %d", (x + 1));
  else
    printf("Remainder is zero,  x - 1 = %d", (x - 1));

PS: It may also be interesting to know that sometimes it is disastrous to use , operator. For example in the question Strtok usage, code not working, by mistake, OP forgot to write name of the function and instead of writing tokens = strtok(NULL, ",'");, he wrote tokens = (NULL, ",'"); and he was not getting compilation error --but its a valid expression that tokens = ",'"; caused an infinite loop in his program.

Answer 5

The comma operator allows grouping expression where one is expected.

For example it can be useful in some case :

// In a loop
while ( a--, a < d ) ...

But in you case there is no reason to use it. It will be confusing... that's it...

In your case, it is just to avoid curly braces :

if(cond)
    perror("an error occurred"), exit(1);

// =>
if (cond)
{
    perror("an error occurred");
    exit(1);
}

A link to a comma operator documentation.

Answer 6

There appear to be few practical uses of operator,().

Bjarne Stroustrup, The Design and Evolution of C++

Most of the oft usage of comma can be found out in the wikipedia article Comma_operator#Uses.

One interesting usage I have found out when using the boost::assign, where it had judiciously overloaded the operator to make it behave as a comma separated list of values which can be pushed to the end of a vector object

#include <boost/assign/std/vector.hpp> // for 'operator+=()'
using namespace std;
using namespace boost::assign; // bring 'operator+=()' into scope

{
    vector<int> values;  
    values += 1,2,3,4,5,6,7,8,9; // insert values at the end of the container
}

Unfortunately, the above usage which was popular for prototyping would now look archaic once compilers start supporting Uniform Initialization

So that leaves us back to

There appear to be few practical uses of operator,().

Bjarne Stroustrup, The Design and Evolution of C++

Answer 7

In your case, the comma operator is useless since it could have been used to avoid curly braces, but it's not the case since the writer has already put them. Therefore it's useless and may be confusing.

Answer 8

The boost::assign overloads the comma operator heavily to achieve this kind of syntax:

vector<int> v; 
v += 1,2,3,4,5,6,7,8,9;

Answer 9

It could be useful for the itinerary operator if you want to execute two or more instructions when the condition is true or false. but keep in mind that the return value will be the most right expression due to the comma operator left to right evalutaion rule (I mean inside the parentheses)

For instance:

a<b?(x=5,b=6,d=i):exit(1);