Need explanation for the following expression in c++

    static constexpr char const* const s_empty = "";

More like a validation question. As per my understanding here
constexpr would make s_empty specifier declares that it is possible to evaluate the value of the variable at compile time. And that would mean that the compiler can replace it for const folding.

char/cost* would make assignment to the pointer not feasible and the const in the end would make the referenced variable unchangeable.

I hope that is correct

> constexpr would make s_empty specifier declares that it is possible to evaluate the value of the variable at compile time

constexpr enforces that the variable is initialized by a constant expression and makes the variable usable as part of other constant expressions. Constant expressions can be evaluated at compile-time and essentially a compiler has to do the evaluation of the variable's value at compile-time if marked constexpr (since it needs to diagnose whether the initialization is a constant expression).

For example, if you need to calculate the extent of an array variable and the calculation requires use of s_empty, then s_empty (likely) needs to be constexpr in order to make the calculation a constant expression. Extent of array variables are one of the contexts that require constant expressions.

> And that would mean that the compiler can replace it for const folding.

The compiler doesn't need to respect constexpr to determine whether or not constant folding is possible. Under the as-if rule it can always constant fold (or do any other optimization) as long as the observable behavior of the program doesn't change.

It may however adjust its internal heuristics with constexpr, since constexpr essentially forces calculation of the value anyway. However, for non-local static storage duration variables, the compiler has to check whether the initialization is a constant expression anyway, regardless of constexpr, because such variables may not have dynamic initialization (at runtime) if they are initialized by constant expressions.

> char/cost* would make assignment to the pointer not feasible

const on the left-hand side applies to char, not the pointer. It makes it so that the value that the pointer points to can't be modified. That's expected since you point it to a string literal, which are not allowed to be modified (and are already themselves const).

> and the const in the end would make the referenced variable unchangeable.

The const at the end makes the pointer value non-modifiable, but is completely redundant, because constexpr already implies a top-level const.