is it legal to call .clear(), .shrink_to_fit(), .empty() on a moved from std::vector?

Question

As a specific subcase of these two questions:

one wonders: Is it legal to call .clear(), .chrink_to_fit(), .empty() on a moved-from std::vector before assigning a new vector to it? I could ask about push_back() but I don't know what that would give, since it's not safe to rely on a moved from vector being empty.

What is clear is that destruction, as well as assignment from a new vector is legal.

std::vector<int> fs = getVec();
giveVecs(std::move(fs));
fs.empty();  // 1.?
fs.size();   // 2.?
fs.shrink_to_fit(); // 3.?
fs.clear(); // //4. ?
fs = {} ; // 5. Should be fine, but weird when we have .clear()
fs.push_back(1); //

Edit:

I should clarify, that some operations do have preconditions: Therefore, (as you can read in the other questions), not All operations are legal after a move.

My question can therefore be restated like this: Are there any preconditions on either of the three operations? One source of problems could be fine print related to the allocator of the moved from object.

score 6 · Answer 1 · answered Apr 08 '18 at 23:02

6

Yes. Moving an object leaves it in an unspecified, but valid state.

So you can call clear, shrink_to_fit, empty, push_back, etc.

But you should probably start with clear due to that unspecified qualifier :) .

answered Apr 08 '18 at 23:02

druckermanly

2,694
15
27

4

To add to this, "valid but unspecified" state implies that you can call functions on the object that have no preconditions, but no others. – Brian Bi Apr 08 '18 at 23:05
1

That is the point of the question: Does any of the listed methods have preconditions? – Johan Lundberg Apr 09 '18 at 06:02
Does "unspecified" mean the size is also unspecified? Or is the size the same as before it was moved from? – pooya13 Jun 23 '21 at 00:41
Yes, the size is also unspecified. – druckermanly Jun 24 '21 at 05:14

score 0 · Answer 2 · answered Apr 10 '18 at 20:00

The legal but unspecified state might be truly empty (using internal buffer move); it might be the content of the moved-to container (using swap), it could be that it still has the memory from the moved-to container; but all the elements destructed, and size() reporting zero (swap & clear()).

Or it might be any number of other things I haven't thought of, but they should all look like valid states of the container.

score -1 · Answer 3 · answered Apr 08 '18 at 23:04

-1

A moved object is in a valid, but unspecified state. Through the magic of Google, the relevant part of the standard is 17.6.5.15 [lib.types.movedfrom]

Objects of types defined in the C++ standard library may be moved from (12.8). Move operations may be explicitly specified or implicitly generated. Unless otherwise specified, such moved-from objects shall be placed in a valid but unspecified state.

As to what's legal for a moved std::vector, it probably depends what the other function did to it. My hunch is that with most implementations you can do pretty much anything you want, but I don't believe that's guaranteed anywhere. It's possible that all the member functions will fail (valid could mean they don't crash, but the object effectively stays useless).

answered Apr 08 '18 at 23:04

Stephen Newell

7,330
1
24
28

I don't know what kind of standard library would consider "you can call member functions of this object... but they do noting" as a "valid state." (More rigorously, you should be able to call any function that either has no preconditions (`empty`, `size`, etc.) , or has preconditions you can verify (`operator[]` after checking `size`). – druckermanly Apr 08 '18 at 23:07
@druckermanly Agreed any standard library that operates like that would be terrible, but it's legal to set a zombie bit or something. It's a question of what's legal vs what's moral. – Stephen Newell Apr 09 '18 at 00:36

is it legal to call .clear(), .shrink_to_fit(), .empty() on a moved from std::vector?

3 Answers3