What lasts after using std::move c++11

Question

After using std::move in a variable that might be a field in a class like:

class A {
  public:
    vector<string>&& stealVector() {
      return std::move(myVector);
    }
    void recreateMyVector() {
    }
  private:
    vector<string> myVector;        
};

How would I recreate the vector, like a clear one? What is left in myVector after the std::move?

Answer 1

The common mantra is that a variable that has been "moved-from" is in a valid, but unspecified state. That means that it is possible to destroy and to assign to the variable, but nothing else.

( Stepanov calls this "partially formed", I believe, which is a nice term.)

---

To be clear, this isn't a strict rule; rather, it is a guideline on how to think about moving: After you move from something, you shouldn't want to use the original object any more. Any attempt to do something non-trivial with the original object (other than assigning to it or destroying it) should be carefully thought about and justified.

However, in each particular case, there may be additional operations that make sense on a moved-from object, and it's possible that you may want to take advantage of those. For example:

• The standard library containers describe preconditions for their operations; operations with no preconditions are fine. The only useful ones that come to mind are clear() , and perhaps swap() (but prefer assignment rather than swapping). There are other operations without preconditions, such as size() , but following the above reasoning, you shouldn't have any business inquiring after the size of an object which you just said you didn't want any more.

• The unique_ptr<T, D> guarantees that after being moved-from, it is null, which you can exploit in a situation where ownership is taken conditionally :

   std::unique_ptr<T> resource(new T); std::vector<std::function<int(std::unique_ptr<T> &)> handlers = /* ... */; for (auto const & f : handlers) { int result = f(resource); if (!resource) { return result; } } 

  A handler looks like this:

   int foo_handler(std::unique_ptr<T> & p) { if (some_condition)) { another_container.remember(std::move(p)); return another_container.state(); } return 0; } 

  It would have been possible generically to have the handler return some other kind of state that indicates whether it took ownership from the unique pointer, but since the standard actually guarantees that moving-from a unique pointer leaves it as null, we can exploit that to transmit that information in the unique pointer itself.

Answer 2

Move the member vector to a local vector, clear the member, return the local by value.

std::vector<string> stealVector() {
    auto ret = std::move(myVector);
    myVector.clear();
    return ret;
}

Answer 3

What is left in myVector after the std::move?

std::move doesn't move, it is just a cast. It can happen that myVector is intact after the call to stealVector() ; see the output of the first a.show() in the example code below. (Yes, it is a silly but valid code.)

If the guts of myVector are really stolen (see b = a.stealVector(); in the example code), it will be in a valid but unspecified state. Nevertheless, it must be assignable and destructible; in case of std::vector , you can safely call clear() and swap() as well. You really should not make any other assumptions concerning the state of the vector.

How would I recreate the vector, like a clear one?

One option is to simply call clear() on it. Then you know its state for sure.

---

The example code:

#include <initializer_list>
#include <iostream>
#include <string>
#include <vector>
using namespace std;

class A {
  public:
    A(initializer_list<string> il) : myVector(il) { }
    void show() {
      if (myVector.empty())
        cout << "(empty)";
      for (const string& s : myVector)
        cout << s << "  ";
      cout << endl;
    }
    vector<string>&& stealVector() {
      return std::move(myVector);
    }
  private:
    vector<string> myVector;        
};

int main() {
  A a({"a", "b", "c"});
  a.stealVector();
  a.show();
  vector<string> b{"1", "2", "3"};
  b = a.stealVector();
  a.show();
}

This prints the followings on my machine:

abc
(empty)

Answer 4

Since I feel Stepanov has been misrepresented in the answers so far, let me add a quick overview of my own:

For std types (and only those), the standard specifies that a moved-from object is left in the famous "valid, but unspecified" state. In particular, none of the std types use Stepanov's Partially-Formed State, which some, me included, think of as a mistake.

For your own types, you should strive for both the default constructor as well as the source object of a move to establish the Partially-Formed State, which Stepanov defined in Elements of Programming (2009) as a state in which the only valid operations are destruction and assignment of a new value. In particular, the Partially-Formed State need not represent a valid value of the object, nor does it need to adhere to normal class invariants.

Contrary to popular belief, this is nothing new. The Partially-Formed State exists since the dawn of C/C++:

int i; // i is Partially-Formed: only going out of scope and
       // assignment are allowed, and compilers understand this!

What this practically means for the user is to never assume you can do more with a moved-from object than destroy it or assign a new value to it, unless, of course, the documentation states that you can do more, which is typically possible for containers, which can often naturally, and efficiently, establish the empty state.

For class authors, it means that you have two choices:

First, you avoid the Partially-Formed State as the STL does. But for a class with Remote State, eg a pimpl'ed class, this means that to represent a valid value, either you accept nullptr as a valid value for pImpl , prompting you to define, at the public API level, what a nullptr pImpl means, incl. checking for nullptr in all member functions.

Or you need to allocate a new pImpl for the moved-from (and default-constructed) object, which, of course, is nothing any performance-conscious C++ programmer would do. A performance-conscious C++ programmer, however, would also not like to litter his code with nullptr checks just to support the minor use-case of a non-trivial use of a moved-from object.

Which brings us to the second alternative: Embrace the Partially-Formed State. That means, you accept nullptr pImpl , but only for default-constructed and moved-from objects. A nullptr pImpl represents the Partially-Formed State, in which only destruction and assignment of another value are allowed. This means that only the dtor and the assignment operators need to be able to deal with a nullptr pImpl , while all other members can assume a valid pImpl . This has another benefit: both your default ctor as well as the move operators can be noexcept , which is important for use in std::vector (so moves and not copies are used upon reallocation).

Example Pen class:

class Pen {
    struct Private;
    Private *pImpl = nullptr;
public:
    Pen() noexcept = default;
    Pen(Pen &&other) noexcept : pImpl{std::exchange(other.pImpl, {})} {}
    Pen(const Pen &other) : pImpl{new Private{*other.pImpl}} {} // assumes valid `other`
    Pen &operator=(Pen &&other) noexcept {
        Pen(std::move(other)).swap(*this);
        return *this;
    }
    Pen &operator=(const Pen &other) {
        Pen(other).swap(*this);
        return *this;
    }
    void swap(Pen &other) noexcept {
        using std::swap;
        swap(pImpl, other.pImpl);
    }
    int width() const { return pImpl->width; }
    // ...
};