Is constexpr a "hint" (like inline) or "a binding request" to the compiler?

Is constexpr a “hint” (like inline) or “a binding request” to the compiler?

It is neither. Forget about when it is evaluated. Everything (with a few minor exceptions, notably involving volatile) is evaluated whenever the compiler deems it necessary to produce the behaviour of the C++ abstract machine. There isn't much else to say about when things are evaluated.

The compiler is free to produce code that evaluates what would be constant expressions at runtime if that doesn't produce a different behaviour. It is free to produce code that evaluates things not marked constexpr at compile-time if it has the smarts.

If not about compile-time vs runtime, what is constexpr about, then?

constexpr allows things to be treated as constant expressions. Anything marked constexpr must have the possibility of producing a constant expression in some way.

In the case of functions, they can be able to produce constant expressions with some arguments but not others. But as long as there is some set of arguments that can result in a constant expression, a function can be marked constexpr. If such a set of arguments is used in a function call, that expression is a constant expression. Does that mean it is evaluated at compile-time? See above. It's evaluated when the compiler deems appropriate. The only thing it means is that you can use it in a context requiring a constant expression.

For variables, either they are constant expressions or not. They have no arguments, so if constexpr they always have to be initialised with constant expressions.

TL;DR: constexpr is about tagging things as being usable in constant expressions, not about deciding when to evaluate them.

With that out of the way, it appears your function template is ill-formed. There is no set of arguments that could result in a constant expression. The standard doesn't require a diagnostic for this, though.

constexpr functions can be used to evaluate compile time constants. So it is possible to use it like:

 constexpr int func(int a) { return a+2; } char x[func(10)]; 

If func is called during runtime, the compiler can evaluate this expression before if possible. But that is not a must but normally done if the input is also const.

It is also important to have constexpr constructors. This is the only chance to get non POD classes constexpr objects.

 class Point { private: int x; int y; public: constexpr Point( int _x, int _y) : x(_x), y(_y) {} constexpr int GetX() const { return x; } }; constexpr Point p{1,2}; int main() { char i[p.GetX()]; return 0; } 

The complete answer to your question has two aspects:

1. A constexpr function can only be evaluated at compile-time when all arguments can be evaluated at compile-time. It can still be used as a normal function which is evaluated at runtime.

2. An constexpr variable must be initialized with a value evaluated at compile-time. The compiler has to raise an error if it cannot do this.

You could assign the hash code to a constexpr variable and then get a compiler output:

#include <typeinfo> #include <array> template<typename T> std::size_t constexpr getID() { return []() {constexpr size_t id = typeid(T).hash_code(); return id;}(); } int main() { // both statement generate compiler errors //std::array<int, typeid(int).hash_code()> a; //constexpr size_t y = typeid(int).hash_code(); size_t x = getID<int>(); }