问题
In the process of answering this question on SO for C++11, I realized that in C++03 (as well as in C) the use of the comma operator is explicitly forbidden in a constant-expression.
Paragraph 5.19/1 of the C++03 Standard on constant expressions says:
[...] 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.
In C++11, however, that last part mentioning the comma operator seems to be vanished. And while paragraph 5.19/2 of the C++11 Standard clearly specifies that assignment, increment, decrement, and non-constexpr function call expressions shall not appear as sub-expressions of a constant-expression, the usage of the comma operator does not seem to be forbidden anymore.
For instance, the following program compiles fine on GCC 4.7.2 and Clang 3.3 with std=c++11 (apart from compiler warnings saying the comma operator has no effect and the x and arr variables are unused):
int main()
{
constexpr int x = (0, 42);
int arr[(0, 42)];
}
However, it must be said that even the following program compiles fine with the -std=c++03 option (both on Clang and GCC), which is clearly not correct, given the above quote from the C++03 Standard:
int main()
{
int arr[(0, 42)];
}
QUESTION:
Is there a difference between C++03 and C++11 as to whether or not the comma operator is allowed in a constant expression, or am I missing something?
As a bonus (non-constructive) question, I would be interested in knowing why the comma operator cannot be used in a constant expression in C++03.
回答1:
Yes, I believe this is a change between C++03 and C++11. I believe it was done for roughly the reason to which you allude -- that there's no particularly good reason a comma operator can't be part of a constant expression.
I believe the rule in C++03 originated from the rule in C (C90, §6.4):
Constant expressions shall not contain assignment, increment, decrement, function-call, or comma operators, except when they are contained within the operand of a sizeof operator.
As to why the comma operator was prohibited in constant expressions in C, I can only speculate. My immediate guess would be to assure that a definition like:
int x[5, 2];
...would be rejected. If it were allowed, it could lead the programmer to the mistaken belief that he'd defined a 5x2 element array (for a total of 10 elements), when (if a comma operator were allowed there) he'd really defined x with only 2 elements (and the 5 was effectively ignored completely).
As to why the C++ committee considered this a more acceptable risk than the C committee, I'd guess it comes down to a fairly simple situation: C provides nearly no alternative, so arrays are used quite a bit. C++, on the other hand, provides both std::array and std::vector, leaving extremely few situations in which there's much reason to use a "raw" array, so the problem is a lot less likely to arise.
回答2:
However, it must be said that even the following program compiles fine with the -std=c++03 option (both on Clang and GCC), which is clearly not correct, given the above quote from the C++03 Standard
Not so fast. You need to also use -pedantic (or -pedantic-errors) to get Clang and GCC to strictly enforce the C++03 rules. With that, GCC trunk says:
<stdin>:1:16: error: array bound is not an integer constant before ‘]’ token
and Clang trunk says:
<stdin>:1:19: error: variable length arrays are a C99 feature [-Werror,-Wvla-extension]
void f() { int arr[(0, 42)]; }
^
As you note, this code is valid C++11. However, top-level commas are still not valid in C++11, because a constant-expression in the C++11 grammar is a kind of conditional-expression (where a top-level comma is not permitted). Thus:
int arr[0, 42];
is still ill-formed.
来源：https://stackoverflow.com/questions/16576933/is-the-comma-operator-allowed-in-a-constant-expression-in-c11