Literal Type, when empty

[mccann]

I wanted to drop this in to replace std::vector, but unfortunately I am unable to.

With std::vector, I am able to use an empty/default constructed instance as a 'literal value' ie, the following static_assert can be evaluated at compile time:

    constexpr auto foo = std::vector<uint8_t>{};
    static_assert(foo.empty());

Looking at the source, I see that the code specifically handles consteval contexts and (if I am reading correctly) always uses allocator. This explains the error about an empty constexpr small_vector<> containing heap allocations, and I imagine/guess that this is to avoid difficulty in switching between "heap" and "inline" storage in a consteval context.

Anyway, not sure if this is something that should even be supported, but I don't see a technical reason why small_vector couldn't be literal when contents fit inline, or at least when empty. And it would be one more way it is compatible with std::vector.

[gharveymn]

Thanks for the discussion. The reason that constant expressions only use the heap allocator actually has to do with the fact that uninitialized values are not allowed in constant expressions. Due to the fact that the inline buffer is not initialized in this implementation, compilation will fail.

However, you will find that if you should be able to compile

    constexpr auto foo = gch::small_vector<uint8_t, 0>{};
    static_assert(foo.empty());

and this is because in this case, we switch to an implementation which doesn't actually have any inline buffer at all.

Also, I don't think that your use case of default construction for a literal constexpr value is actually explicitly legal by the standard. I don't have time to cite this right now (I am open to being proven wrong), but have gone through the exercise before, hence why the code snippet above actually works. Echoing the section in the README, this type works not for literal values, but in the evaluation of constant expressions, just the same as std::vector.

[mccann]

I see! So std::vector working empty could be an accidental, non intended behaviour. Also, thanks for the clarification on uninitialized values, I now remember running across that requirement a couple years ago. In this particular use case it was just handy to use the empty vector as literal as a sort of place holder for empty values (and it so happens to need to be literal in that code path). I already have worked around this, so not a big problem. Thank you for response, great work.