What's so hard about constexpr allocation?

C++20 introduced the ability to perform allocations during constant evaluation, a significant change from previous standards where such allocations were not permitted. However, this capability is limited; any allocation must be deallocated within the same constant evaluation context. This limitation prevents the declaration of `constexpr std::vector` and similar constructs, which remains an issue in C++23 and may persist into C++26. The challenges are twofold: the constant destruction problem, which concerns ensuring that allocations can be safely deallocated, and the constant access problem, which deals with determining when the contents of an allocation can be treated as constant expressions.

The constant destruction problem arises when an allocation persists beyond its intended scope, leading to potential runtime errors if destructors are invoked on memory allocated during compile time. The constant access problem highlights the risk of accessing mutable data through pointers that are declared as constant, which can yield inconsistent results during execution.

To address these issues, the language must establish rules that prevent unsafe allocations while allowing useful constructs like `std::vector`. This involves distinguishing between different types of allocations, such as transient and non-transient allocations, and ensuring that mutable access does not compromise the integrity of constant expressions. The complexity of these problems suggests that a comprehensive solution is still needed to fully leverage `constexpr` allocations in C++.