- Not all class objects have a moved-from state  - Some objects need tidying up even in their moved-from state, e.g. freeing memory from the heap  - Some objects can't even store a flag; to add id nevertheless, why not use std::optional?   your 3 changes work with std::optional<T>: 1) destruction of a known-to-be-empty std::optional will be optimized to a no-op 2) getting an empty std::optional is possible 3) creating/emplacing an empty std::optional in raw memory is possible   What you probably want instead is an in-band signalled optional interface. There sure are some C++ papers for it? Like a HANDLE; and 0, or -1, or nullptr signals empty. And the zero HANDLE can just be destructed as a NO-OP whereas the valid HANDLE needs deallocation or closing some hardware interface.   -----Ursprüngliche Nachricht----- Von:Frederick Virchanza Gotham via Std-Proposals <std-proposals_at_[hidden]> Gesendet:Mo 27.10.2025 11:48 Betreff:Re: [std-proposals] Replace an object -- but retain old object if new object fails to construct An:std-proposals_at_[hidden]; CC:Frederick Virchanza Gotham <cauldwell.thomas_at_[hidden]>; On Fri, Oct 24, 2025 at 4:08 PM Thiago Macieira wrote: > > std::optional already guarantees that. My original use case used 'optional', but then Arthur came in and made it more generic with a function as follows:    template<typename T, typename... Params>    void replace(T*, Params&&...); and so sometimes we might want to be certain that the object is safe to destroy. I'm going off on a bit of a tangent here, but with regard to objects that have been moved from, I wonder would the following three changes be welcome in the language? Change No. 1:    The destruction of a moved-from object should always be equivalent to a no-op and can therefore be elided Change No. 2:    A new consteval standard library function that returns a moved-from PRvalue:    template<typename T>    requires (!is_reference_v<T>)    consteval T moved_from(void)    {        . . .    } Change No. 3:    A new constexpr standard library function that emplaces a moved-from object:    template<typename T>    requires (!is_reference_v<T>)    void emplace_moved_from(void *const p)    {        assert( 0 == (reinterpret_cast<uintptr>(p) % alignof(T)) );        . . .    } -- Std-Proposals mailing list Std-Proposals_at_[hidden] https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals