C++20 P0784R7 与 P1004R2 constexpr std::vector 相比，非瞬态分配太脆弱

Question

I would like to create an extensive constexpr data repository in C++20. Tens of thousands of hopefully native C++ objects loaded as "text segment" ie demand paged into the process and shared between instances (the code is generated).

The objects are referencing each other and need indexing by various properties, cross-referencing etc. all hopefully done at compile time. This calls for constexpr (associative) containers, but it can't be done with templatized (by size, hash size, etc.) containers, as everything needs to remain polymorphic.

First it seems impossible, as C++20 P0784R7 says that non-transient allocation is too brittle, ie dynamically allocated memory is not allowed to be leaked out of constexpr evaluations.

At the same time C++20 P1004R2 says that constexpr std::vector is to be supported. In the latter paper I see all members, including the modification members marked as constexpr . So unless I'm missing something, I can add elements to std::vectors inside constexpr evaluations (compilers don't support it yet, so I can't try).

// 21.3.11.5, modifiers
template<class... Args> constexpr reference emplace_back(Args&&... args);
constexpr void push_back(const T& x);
constexpr void push_back(T&& x);
...

But then why can't I build an allocator<T> around a std::vector<T> and still have non-transient allocations? Aren't the two capabilities "computationally equivalent" ie constexpr std::vector needs non-transient allocation to be implemented, and therefore it can also provide it ?

And when will compilers finally support it? ... or is this suspected contradiction even the reason for the delay?

Answer 1

You have a misunderstanding of transient allocations. Transient allocations are allocations that exist entirely within constant evaluation. For example:

constexpr std::size_t summation(std::vector<unsigned int> const &vi)
{
  std::size_t ret = 0;
  for(auto i : vi)
    ret += i;
  return ret;
}

constexpr auto sum = summation({20, 44, 98});

In the call of summation , the ultimate input source (the braced-init-list and its values) is known entirely at compile time. Yes, there is a vector , but this exists entirely within the constant expression evaluation. The vector object is used to compute the constant value, but the vector itself never leaves constant expression code.

This kind of allocation, one that exists entirely within constant evaluation, is called a "transient allocation". Such allocations are permitted under C++20's rules.

A non-transient allocation would be data "loaded as 'text segment'", and that is what isn't allowed. So your first impression is correct.