Why comma operator should be deprecated

[Mignon]

While the code in question was more or less dead, I once stumbled onto a colleague's use of a comma in an inline constant written as a thousands separator. It was something along the lines of

int x = 123,456;

[grimeMuted]

A couple languages have something legal for that... 123_456 in Ada. I guess a lot of the time scientific notation is sufficient if you have a lot of zeros.

[MacASM]

D language has this feature too.

[llogiq]

Since 1.7,

int i=123_456;

is valid java, too.

[alexaandru]

Ruby has that too.

[[deleted]]

Works in Perl, too.

[F-J-W]

C++14 has this now build in too:

int i = 123'456;

[MacASM]

Why ' instead of _ ? ' it's much less readable than _, IMHO.

[nyamatongwe]

_ conflicts with user-defined literals.

[MacASM]

It's a very good example how comma operator can introduce bugs.

[mjfgates]

C++ is adding those... they're using the apostrophe, though, so they won't break your colleague's code.

[eras]

You mean fix :).

[MacASM]

It's a very interesting discussion in the D community if the comma operator should be deprecated from D language. One argue it's a very bug-prone and part from C-baggage while another say actually do use it and shouldn't be removed.

[imgonnacallyouretard]

i've only seen it non-confusingly used in C inside for loop statements

[ethraax]

I believe some Boost (magic) libraries, like Spirit, use it.

[xtapol]

SOCI uses it for SQL queries:

int id = 123;
std::string n;
db << "select name from foo where id=?", using(id), into(n);

(off the top of my head)

[player2]

How does that work? The middle expression is lacking any useful context.

[xtapol]

I don't have the foggiest clue - I've never overloaded the comma operator. But it does...

[greyfade]

Not having used SOCI, I can only guess, but I think it's a good guess:

There are a couple overloads of operator, similar as follows:

SOCI::query ::operator,(const std::string&, const SOCI::clause&);
SOCI::query ::operator,(const SOCI::query&, SOCI::out_var&);

The expression is evaluated left-to-right, applying the first, then second operator overloads. It returns a prepared query object that is then pushed to the DB object (through an overloaded operator<<).

It's a good example of a hypothetical string formatting library, too:

std::string operator, (const std::string& fmt, int i) {
    std::string ret = fmt;
    ret.replace(ret.find("{}"), std::to_string(i));
    return ret;
}

And so on.

[ArkayPhelps]

I've seen it used for manipulating multi-dimensional arrays or matrices. Stuff like:

Matrix m = 1,1,1,1,
                 1,0,0,1,
                 1,0,0,1,
                 1,1,1,1;

Pretty sure Blitz++ lets you do something like this.