Why does constexpr prevent auto type deduction in this statement?

Question

In the following if I use constexpr the compiler apparently the compiler says "expression must have a constant value", this happens on MSVC and GCC:

int main() {
    constexpr auto nnn = {
        "this", "sentence", "is", "not", "a", "sentence",
            "this", "sentence", "is", "a", "hoax"
    };
}

Without the constexpr the compiler can deduce that nnn variable is an std::initializer_list<const char*>. And the std::initialiser_list class has a constexpr constructor, why can't this be constexpr?

Answer 1

Type deduction is not failing. The compiler is deducing auto to std::initializer_list<const char*>. You get the same result if you wrote std::initializer_list<const char*> instead of auto.

The initialization fails to be a constant expression (something that can only be checked after all types have been deduced).

It fails to be a constant expression, because std::initializer_list works as if an array with the same storage duration was defined in the same scope to hold the elements and as if the std::initializer_list object held pointers to the beginning and end of that array.

Because that array would have automatic storage duration in your example, the initialization of the std::initializer_list object can't be a constant expression, because the result of a constant expression can only contain pointers to objects with static storage duration. (The value of pointers to an object with automatic storage duration would change each time the initialization is performed, so can't be constant expression results.)

You can force the unnamed array to have static storage duration (as well as the std::initializer_list) by using static:

int main() {
    constexpr static auto nnn = {
        "this", "sentence", "is", "not", "a", "sentence",
            "this", "sentence", "is", "a", "hoax"
    };
}

Answer 2

The constexpr constructor mentioned by OP is the default constructor that creats an empty list. The actual usable constructor doesn't have any standard interface to begin with. One primary requirement of constant expressions is that every invoked function is visible, inlined and sepcified as constexpr. As a result, std::initializer_list just cannot be constexpr. It looked like a necessary abomination when C++11 was about to be completed. I wished it were deprecated by now. I can not imagine any use case without alternatives. Usage as function/constructor argument can be handled with std::span<const T> it just requires a bit more typing:

constexpr auto foo(std::span<std::uint64_t> arr){
   return std::ranges::fold_left(arr,0ull,std::plus<>{});
};

auto constexpr N = foo(std::array{1ull, 2, 3});

Other usages are just duplicates of std::array:

constexpr std::array nnn = {
        "this"sv, "sentence", "is", "not", "a", "sentence",
            "this", "sentence", "is", "a", "hoax"
    };//fixed-size array of std::string_views

As of C++23, all std containers have range constructors, So it's just possible to pass in a std::array:

std::vector<int> vec(std::from_range, std::array{1,2,3,4});

IMO, std::initializer_list has no more practical use cases. Everything already has a better substitution.