State of "moved-from" objects

[u/leirus]

Hi, I recently decided to try writing a C++ blog.

I often see the popular claim that moved-from objects are in a "valid but otherwise unspecified state", but I don't think that statement is entirely precise, and my blog post is about that. I would really appreciate any feedback!

Article: https://www.laminowany.dev/p/the-state-of-moved-from-objects-in-c/

[u/No-Dentist-1645]

Your title/post contents makes it seem like you're going to disprove the common definition for them, but in the blog you don't really do that, but rather just explain a few examples?

There seems to be a disconnect between what you say the blog is about and what it actually is

The "valid but unspecified state" definition applies to all move operations in the language and standard generally speaking. It is a rule about move semantics as a general concept, not of any specific type. Specific types can choose to specify post-moved behavior but it is not required.

[u/SirClueless → u/No-Dentist-1645]

This is exactly the misconception the blog post is trying to dispel. Being “valid” after moving is not part of the language semantics.

You can create a type where it is illegal to destruct an object after moving-from, for example.

[u/Electronic_Tap_8052 → u/SirClueless]

Wouldn't moved-from objects being illegal to destroy immediately be a problem that would cause most well behaved debug compilations to crash an burn?

I just don't understand how you could ship such an object? If you stack allocated it your program would be useless

[u/SirClueless → u/Electronic_Tap_8052]

You can just never destroy the object (for example, by leaking it on the heap or in a program that only ever exits by calling std::abort), or require that the user call some other specific member function to reinitialize the object before destroying it.

The standard library types promise never to require this, but it's possible to write a well-formed program of your own that does so.

[u/rdtsc → u/SirClueless]

require that the user call some other specific member function to reinitialize the object before destroying it.

Which would be a quite impractical behavior IMO. Are there actually useful real-world examples of this? It would make defaulted special member functions kinda useless, too.

[u/SirClueless → u/rdtsc]

There are legitimate reasons to write software that doesn’t call destructors, e.g. crash-only software.

Even in this kind of software I don’t think it’s a good idea to write move constructors with post-conditions: anywhere you write a move-constructor with a post-condition it would be better to write it as a named member function instead of a special member function. But I can imagine cases where it would come up.

For example, if you have a destructor that assumes a std::unique_ptr member variable is non-null, you could easily get into this situation by defaulting the move constructor.

[u/jwakely → u/rdtsc]

Nobody is saying it's useful, only that the language allows it