4

I have this code:

const float foo = 5.0F; static_assert(foo > 0.0F, "foo must be greater than 0.");

But in I get the error:

error C2057: expected constant expression

I'm actually doing this correctly and just hasn't properly implemented static_assert, right? In it works as intended.

There has been some commentary of the differences between const and constexpr. I understand this difference, however many compilers support this use of static_assert so I'll ask again, is this legal code or not? I'm not as concerned about which compiler supports it, I'm concerned about whether it's defined under the C++ standard.

Improve this question
5
  • static_assert requires C+11 see: en.cppreference.com/w/cpp/language/static_assert You would need to update your compiler to use this. Commented Oct 26, 2017 at 18:51
  • @RichardCritten Visual Studio 2010 supported it: msdn.microsoft.com/en-us/library/dd293588(v=vs.100).aspx Commented Oct 26, 2017 at 18:52
  • Possible duplicate of const vs constexpr on variables Commented Oct 26, 2017 at 18:53
  • Voting to close. In you particular problem, is that a const can be initialized on runtime, while constexpr should be initialized at compile time Commented Oct 26, 2017 at 18:55
  • @Amadeus There needs to be a ruling on this for constant global variables, can they or can they not be static_asserted, the question you link does not answer that question. This is not a duplicate. Commented Oct 26, 2017 at 19:21

1 Answer 1

Reset to default
3

foo > 0.0F is not a core constant expression:

  1. An expression e is a core constant expression unless the evaluation of e, following the rules of the abstract machine, would evaluate one of the following expressions:

...

(2.7) an lvalue-to-rvalue conversion unless it is applied to

(2.7.1) a non-volatile glvalue of integral or enumeration type that refers to a complete non-volatile const object with a preceding initialization, initialized with a constant expression, or

(2.7.2) a non-volatile glvalue that refers to a subobject of a string literal, or

(2.7.3) a non-volatile glvalue that refers to a non-volatile object defined with constexpr, or that refers to a non-mutable subobject of such an object, or

(2.7.4) a non-volatile glvalue of literal type that refers to a non-volatile object whose lifetime began within the evaluation of e;

foo is of floating-point type, for foo > 0.0F an lvalue-to-rvalue conversion on foo is required, which doesn't match the above conditions, then foo > 0.0F is not considered as constant expression:

A constant expression is either a glvalue core constant expression that refers to an entity that is a permitted result of a constant expression (as defined below), or a prvalue core constant expression whose value satisfies the following constraints

On the other hand, if declare foo as integral type the code would be fine. LIVE (Usingconstexpr instead of const works too. LIVE)

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

So I appreciate the comment, and it must have some merit cause I do see 2.7.1 here. But why does a comparison on foo require an lvalue-to-rvalue conversion? Seems like I'm comparing an lvalue to primitive literal.
@JonathanMee Difficult question. From this answer, "we need the lvalue-to-rvalue conversion to access the value inside an object", so lvalue-to-rvalue conversion is required to extract the value of foo for comparing. More precisely, operator> expects its operand as a prvalue. BTW if you use literal directly code will compile, lvalue-to-rvalue conversion is not required at all.
I have had a hard time finding explicit clarification that a floating point comparison invokes an lvalue to rvalue comparison. Given your standard quote it seems fairly certain that this does happen, but I'd still like explicit clarification before accepting this answer. Question is here: stackoverflow.com/q/46980595/2642059

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.