Ok, thank you for clarifying, I can see your issue now with your example and re-reading the paper. The wording does seem to contradict the idea of shared_ptr being relocatable at all. Imagining a more complicated example:

struct foo
{
    static inline std::shared_ptr<foo>* foo_inst = nullptr;

    ~foo()
    {
        if (foo_inst) printf("%p", foo_inst->get());
    }
};
void bar()
{
    std::shared_ptr<foo> a = std::make_shared<foo>();
    std::shared_ptr<foo> b = std::make_shared<foo>();

    foo::foo_inst = &b;
    a = std::move(b);
    foo::foo_inst = nullptr;
}

Based on how shared_ptr's move constructor is specified (shared_ptr(std::move(other)).swap(*this)), this should print a null pointer, because the destruction of a's foo object doesn't happen until after the contents of b have been moved into the temporary object. If you destroy a before doing a move constructor then the foo's destructor is called before the contents of b has been moved, and so a non-null pointer is printed.

It doesn't seem like shared_ptr can in general meet the isomorphism requirements for being relocatable as proposed, at least not in the case where the destructor of the owned object might have side effects.

On 13 March 2025 15:21:56 GMT, Ell <ell_se_at_[hidden]> wrote:
>
>
>On 3/13/25 15:43, Jennifier Burnett wrote:
>> Could you elaborate on these? You've given some examples of move assignments, but I'm not sure how that would translate to move _construction_, since the examples here seem to be based around the fact that you're assigning to an already existing object rather than constructing a completely new one?
>>
>> Maybe an example of these translated to use trivial relocation would make it clearer?
>
>AFAIUI, if a type is replaceable, then it's possible to, er, replace
>move assignment with destruction + reconstruction. So if std::shared_ptr
>is replaceable, it should be possible to rewrite the previous code as:
>
> template <class T>
> void replace (T& dest, T&& src) {
> dest.~T ();
> new (std::addressof (dest)) T (std::forward<T> (src));
> }
>
> struct X {
> std::shared_ptr<X> x;
> };
>
> int main () {
> std::shared_ptr<X> x = std::make_shared<X> ();
>
> x->x = std::make_shared<X> ();
>
> replace (x, std::move (x)); // (1)
> replace (x, std::move (x->x)); // (2)
> }
>
>But since, in these cases, destroying `dest` causes the destruction of
>`src` before reconstruction, that's obviously invalid.
>