Why can't a placement-new expression be a constant expression?

Question

According to [expr.const]/5.18:

An expression E is a core constant expression unless the evaluation of E, following the rules of the abstract machine ([intro.execution]), would evaluate one of the following:

• a new-expression ([expr.new]), unless the selected allocation function is a replaceable global allocation function ([new.delete.single], [new.delete.array]) and the allocated storage is deallocated within the evaluation of E;

A placement-new expression is not a constant expression.

To solve it, C++20 added std::construct_at. So why can't a placement-new expression be made a constant expression?

Answer 1

So I started a twitter thread on this a while ago here in response to the question:

Current implementations don't allow placement new() in constexpr context.

and I replied:

If we look at p0784r0: https://wg21.link/p0784r0

The paper mentioned two approaches:

• in terms placement new
• in terms of the standard allocator

by the time we get to p0784r3: https://wg21.link/p0784r3

placement new is dropped, IIUC there are implementation issues here.

The reply from Richard Smith was:

Full placement new support is hard for some implementations, so a restricted form is exposed through std::construct_at and allocator_traits::construct. For now in clang, we actually implement a quite general form of placement new, but only allow it inside namespace std.

to which I asked:

I am curious why this is difficult for some implementations or maybe easier why it is not difficult for clang.

and the reply to this was:

I am told that getting from the void* parameter to placement new back to a typed pointer is infeasible for some constexpr evaluators, presumably due to how they represent pointers. construct_at avoids this because it takes a T* not a void*.

Basically it comes down to some implementation don't have the machinery in place to do this in a general way using placement new. This document has some discussions on this but really raises more questions then answers but hints at some details:

Unfortunately this allows placement new to foul analyses which use address value propagation to refine aliasing based on knowing where the pointer points. In the example above, such an optimization may find that the address of bp->buf[0] to be associated with the object a. From that finding, the optimizer may then decide that accesses to the memory ought to be done through a glvalue which may access the stored value of a without invoking undefined behavior (§3.10 [basic.lval]). The initialization done via the new-expression is not such an access.

Answer 2

It follows from:

During an evaluation of a constant expression, a call to an allocation function is always omitted. Only new-expressions that would otherwise result in a call to a replaceable global allocation function can be evaluated in constant expressions.

In short, placement new doesn't qualify here (hint: due to not using a replaceable allocation function).

Answer 3

Placement-new expressions are not constant expressions because they invoke undefined behavior if the object they create is not properly destroyed. This is because placement-new expressions bypass the normal object construction/destruction mechanisms, and the programmer is responsible for invoking the destructor manually. If you want to create an object in a constant expression, you can use std::construct_at to initialize the object at a given address:

int main(int argc, char* argv[]) {
    constexpr auto foo = []() {
        auto buffer = std::array<int, 4>{};
        return std::construct_at(buffer.data(), 1);
    };
    
    static_assert(foo() == 1, "!");
}