If performance is not the motivation, why not make it even more similar to shared_ptr, and safer to use?     Why not have 3 classes:   owning pointer weak pointer promoted pointer   Only the owning pointer may destruct the object. The promoted pointer, as long as it is active, delays the destruction.   The owning pointer (or its user) can decide, what to do, if destruction is delayed or not possible (because there are promoted pointers around. Programmatically that should not happen, but here you can define a response instead of getting UB).     You are safe from the case that the pointer is deleted, while you access it.   -----Ursprüngliche Nachricht----- Von:JOHN MORRISON via Std-Proposals <std-proposals_at_[hidden]> Gesendet:Mo 24.02.2025 20:01 Betreff:Re: [std-proposals] A non-owning but self zeroing smart pointer for single ownership An:std-proposals_at_[hidden]; CC:JOHN MORRISON <inglesflamenco_at_[hidden]>; ptr_to_unique does use a control block. It isn't as burdensome as that of shared_ptr/weak_ptr but it is more than half way there. It also requires the unique_ptr it works with to be fattened by a notifying mechanism (custom deleter) that holds a pointer to the control block.   Performance isn't the motivation. The motivation is to have something that works with unique_ptr because single ownership is often a requirement in a model and I want to hold long term references to items within that model that test as null when they are no longer valid.