How does the move constructor look like if I have a vector (or anything like it) member variable?

Question

The title pretty much sums up my question. In more detail: I know that when I declare a move constructor and a move assignment operator in C++11 I have to "make the other objects variables zero". But how does that work, when my variable is not an array or a simple int or double value, but its a more "complex" type?

In this example I have a Shoplist class with a vector member variable. Do I have to invoke the destructor of the vector class in the move assignment operator and constructor? Or what?

class Shoplist {
public:
    Shoplist() :slist(0) {};
    Shoplist(const Shoplist& other) :slist(other.slist) {};
    Shoplist(Shoplist&& other) :slist(0) {
        slist = other.slist;
        other.slist.~vector();
    }

    Shoplist& operator=(const Shoplist& other);
    Shoplist& operator=(Shoplist&& other);



    ~Shoplist() {};
private:
    vector<Item> slist;
};

Shoplist& Shoplist::operator=(const Shoplist& other)
{
    slist = other.slist;
    return *this;
}

Shoplist& Shoplist::operator=(Shoplist&& other)
{
    slist = other.slist;
    other.slist.~vector();
    return *this;
}

Answer 1

Whatever a std::vector needs to do in order to move correctly, will be handled by its own move constructor.

So, assuming you want to move the member, just use that directly:

Shoplist(Shoplist&& other)
  : slist(std::move(other.slist))
{}

and

Shoplist& Shoplist::operator=(Shoplist&& other)
{
    slist = std::move(other.slist);
    return *this;
}

In this case, you could as AndyG points out, just use = default to have the compiler generate exactly the same move ctor and move assignment operator for you.

Note that explicitly destroying the original as you did is definitely absolutely wrong. The other member will be destroyed again when other goes out of scope.

---

Edit: I did say assuming you want to move the member, because in some cases you might not.

Generally you want to move data members like this if they're logically part of the class, and much cheaper to move than copy. While std::vector is definitely cheaper to move than to copy, if it holds some transient cache or temporary value that isn't logically part of the object's identity or value, you might reasonably choose to discard it.

Answer 2

Implementing copy/move/destructor operations doesn't make sense unless your class is managing a resource. By managing a resource I mean be directly responsible for it's lifetime: explicit creation and destruction. The rule of 0 and The rule of 3/5 stem from this simple ideea.

You might say that your class is managing the slist, but that would be wrong in this context: the std::vector class is directly (and correctly) managing the resources associated with it. If you let our class have implicit cpy/mv ctos/assignment and dtors, they will correctly invoke the corresponding std::vector operations. So you absolutely don't need to explicitly define them. In your case the rule of 0 applies.

---

I know that when I declare a move constructor and a move assignment operator in C++11 I have to "make the other objects variables zero"

Well no, not really. The ideea is that when you move from an object (read: move it's resource from an object) then you have to make sure that your object it's left aware that the resource it had is no more under it's ownership (so that, for instance, it doesn't try to release it in it's destructor). In the case of std::vector, it's move ctor would set the pointer it has to the internal buffer to nullptr.