Constructing an object over itself

Question

In C++ can you reuse the memory of an object by destroying this and then recreating another object of the same type at this? Would it work or would it be UB?

In the following example we seemingly modify a const member variable (live demo).

#include <new>


class Weird {
public:
    Weird(int x) : x(x) {}

    void operator=(int newX) {
        this->~Weird();
        new(this) Weird(newX);
    }

    operator int() const {
        return x;
    }

private:
    const int x;
};


int main() {
    Weird w = 1;
    w = 2;
    return w;
}

Isn't that what `std::move` is supposed to do?? Also your example seems to suffer from untracked pointers (memory leaks), and dangling pointers from copies. — πάντα ῥεῖ, May 30 '23 at 19:15
It is certainly legal and well-defined to do this from a non-member function; there’s even an example (unfortunately) of that in the standard. Of course, if you derive a new type from this monstrosity, you end up creating an abomination that probably won’t do anything useful. — Pete Becker, May 30 '23 at 19:30
at least before C++20 this code has UB. I think it is allowed in C++20 — NathanOliver, May 30 '23 at 19:32
That's a reasonable question IMO, I don't see any reason to downvote it. The fact that code like this wouldn't ever pass my code review doesn't mean the question about it is bad. — Yksisarvinen, May 30 '23 at 19:33
@Yksisarvinen Agreed. Just because the question is scary from a code review perspective doesn't mean it's bad. C++ has a lot of interesting rabbit holes. — tadman, May 30 '23 at 19:34
Is the code of an object valid after the instance has been deleted? How can you do `new (this);` when `this` has been deleted? — Thomas Matthews, May 30 '23 at 20:08
@ThomasMatthews `this` hasn't been deleted. The object it points to has been destroyed, but the memory lives as long as `w` does. — NathanOliver, May 30 '23 at 20:12

score 1 · Accepted Answer · edited May 31 '23 at 05:59

1

Would it work or would it be UB?

It will work and has defined behavior since C++20. Doing it with a const member variable isn't allowed in prior versions.

after the lifetime of an object has ended and before the storage which the object occupied is reused or released, any pointer that represents the address of the storage location where the object will be or was located may be used but only in limited ways.

— C++20 standard [basic.life/6]

this is such a pointer.

If, after the lifetime of an object has ended and before the storage which the object occupied is reused or released, a new object is created at the storage location which the original object occupied, a pointer that pointed to the original object, a reference that referred to the original object, or the name of the original object will automatically refer to the new object and, once the lifetime of the new object has started, can be used to manipulate the new object, if the original object is transparently replaceable by the new object.

— C++20 standard [basic.life/8]

Weird is transparently replaceable by Weird.

edited May 31 '23 at 05:59

Dr. Gut

2,053
7
26

answered May 30 '23 at 20:45

Ted Lyngmo

93,841
5
60
108

1

There's also https://eel.is/c++draft/basic.life#8.4, that says this doesn't work for base classes and `[[no_unique_address]]` data members. – HolyBlackCat May 30 '23 at 20:53
@HolyBlackCat Yes, there are a lot of conditions that needs to be fulfilled and OPs code fullfills them all as far as I can see. – Ted Lyngmo May 30 '23 at 20:56
Related question: Is this still legal/well-defined if you delete the line `this->~Weird();`? – Matt May 30 '23 at 20:57
@Matt Good question. I've seen it both with and without explicitly calling the destructor. I'm not 100% about the answer. Perhaps it's safest to always do it even if not needed for trivial types. – Ted Lyngmo May 30 '23 at 20:59
1

@Matt Only if the destructor is trivial. – NathanOliver May 30 '23 at 21:00
*"OPs code fullfills them all"* Mhm, my point is that this class design is unsound in general, because you can't guarantee that those conditions will always be met. – HolyBlackCat May 30 '23 at 21:09
@HolyBlackCat From _"The question is purely theorethical"_ and _"I just want to understand things better"_ I drew the conclusion that this is just a toy example and OP wants to know if what's presented in the question has UB or not. At least, that's how I saw it. – Ted Lyngmo May 30 '23 at 21:17
1

@TedLyngmo: You saw it right. Thanks. – Dr. Gut May 30 '23 at 23:09

Constructing an object over itself

1 Answers1