Recently when answering a question I realized that the comma operator is allowed in a constant expression in C++11 as long as the expression is surrounded by (), for example:
int a[ (1, 2) ] ;
Pre C++11 it is forbidden to use the comma operator in a constant expression, from the draft pre C++11 standard section 5.19 Constant expressions which says (emphasis mine):
[...]In particular, except in sizeof expressions, functions, class
objects, pointers, or references shall not be used, and assignment,
increment, decrement, function-call, or comma operators shall not be
used.
Why was the comma operator not allowed in a constant expression pre C++11 and why was this restriction lifted?
We can find the answer to this in the std-discussion group Comma operator in constant-expression thread where Gabriel Dos Reis says:
For C++11 I proposed to allow it because the restriction appeared
arbitrary and all reasons I've heard as rationale for its ban appear
very unconvincing and specious to me.
and Richard Smith earlier in the thread notes some of the uses of the comma operator in a constant expression in both C++11 and C++14:
I disagree with your argument and your conclusion. In C++11, the comma
operator is useful within constexpr functions, because we aren't
allowed multiple statements:
template<typename T> constexpr T my_array<T>::at(size_type n) {
return (n < size() || throw "n too large"), (*this)[n]; }
In C++14, it's useful in essentially all of the cases where it's
useful outside of constant expressions:
constexpr void do_stuff(int x[]) {
for (int i = 0, j = 100; i != j; ++i, --j)
x[i] = x[j]; }
More philosophically, we shouldn't ban things from constant
expressions simply because we're not imaginative enough to find the
cases where they're genuinely useful. Constant expressions should not
be a semi-random sublanguage of C++, missing random features, to the
extent that we can avoid that. These days, top-level commas are
prohibited mostly because constant-expressions tend to occur in
contexts where a comma would mean something else.
Note it was argued that his C++11 example is not correct since the the expression containing the comma operator should be in () but his example gives the essence of the argument. The argument would be based on the grammar from section 5.19 Constant expressions:
constant-expression:
conditional-expression
we can not get to comma operator from a conditional-expression but we can get to primary-expression which gets us to ( expression ) and we can then get to the comma operator from expression.
T.C. points out that this may not be the case since the relevant section seems vague on this point.
