constant-expression

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

Please see the update for a better sample of the problem. The original code has a mix of issues which muddies the picture : This question Why can I call a non-constexpr function inside a constexpr function? presented the following code #include <stdio.h> constexpr int f() { return printf("a side effect!\n"); } int main() { char a[f()]; printf("%zd\n", sizeof a); } Which as I answer is ill-formed but gcc 4.8.2 allows it ( see it live ). But, if we use the -fno-builtin flag gcc generates an error ( see it live ): error: call to non-constexpr function 'int printf(const char*, ...)' return printf(

If we look at the draft C++ standard section 5.1.2 Lambda expressions paragraph 2 says ( emphasis mine going forward ): The evaluation of a lambda-expression results in a prvalue temporary (12.2). This temporary is called the closure object. A lambda-expression shall not appear in an unevaluated operand (Clause 5). [ Note: A closure object behaves like a function object (20.8).—end note ] and section 5.19 Constant expressions paragraph 2 says: A conditional-expression is a core constant expression unless it involves one of the following as a potentially evaluated subexpression (3.2), but

In C++11 and C++14, why do I need constexpr in the following snippet: class Foo { static constexpr double X = 0.75; }; whereas this one produces a compiler error: class Foo { static const double X = 0.75; }; and (more surprisingly) this compiles without errors? class Foo { static const double X; }; const double Foo::X = 0.75; In C++03 we were only allowed to provide an in class initializer for static member variables of const integral of enumeration types, in C++11 we could initialize a static member of literal type in class using constexpr. This restriction was kept in C++11 for const