移动构造函数是否需要可移动的属性？

Question

I am trying to wrap my head around move constructors and am hoping to get some more insights through this question. Here is a simple class.

class A
{
 private:
   vector<B> Bs;
 public:
   /*
   ..
   */

   A(A&& other)
   : Bs
   {
      Bs = other.Bs;
   }
}

Does my move constructor looks correct even if B does not have a move constructor? Will the move constructor be effective even if I haven't explicitly written a move assignment for the object of class B ? If not, does it mean that if one wants to move any object, (s)he first have to ensure each attribute is also moveable?

Answer 1

If your object contains objects that are move-able (such as std::vector ), the default move constructor will take care of the move, so you don't need to do anything. Try to use the Rule of Zero .

In your case, no, the move ctor won't do the right thing. It will copy, since in

Bs = other.Bs;

other.Bs is a lvalue inside the function since it has a name (yes, it refers to a rvalue reference but other itself is a lvalue). You need

Bs = std::move(other.Bs);

or better

A(A&& other) : Bs(std::move(other.Bs)) {}

But again, in this case you really shouldn't write any user-defined move constructor at all.

Highly recommended read from Howard Hinnant , the person who contributed probably the most to the concept of move semantics: http://www.slideshare.net/ripplelabs/howard-hinnant-accu2014

Answer 2

No it is not. Your line here:

Bs = other.Bs;

You are doing copy assignment. Being in the move constructor body won't change expression value type. lvalue are still lvalues and rvalue are still rvalue.

To do move assignment, it would look like this:

Bs = std::move(other.Bs);

But it is still not as efficient as it could be.

There's another problem. Your code is not compiling because you have committed the braces for the std::vector constructor. In fact, this is where you should move the value. Here's an example:

// a kitten dies when your move constructor is not noexcept
A(A&& other) noexcept
  // in the move constructor of A, we move construct it's member too.
: Bs{std::move(other.Bs)}
// empty body
{}

The best solution of all is this:

You are right, it's empty. If you don't put any constructors, the compiler will do it for you.

If you want to add other constructor but let the compiler add it's own move constructor, you can explicitly default it:

// bonus: noexcept when it can.
A(A&&) = default;

---

One last thing. If your class contains another one that is not moveable but copiable, it will do what it can: copy construct it.

Let the type C be a non-moveable class but copiable.

Here's an example:

// the `C&&` from the move will bind to the `const C&` of the operator=
auto anotherC = std::move(aC);

Answer 3

The move constructor here will be "effective" in that it will be called when an A object is constructed from an rvalue of type A . It will work just fine, creating a valid copy of the other object. However, it's not as effective as it could be, since it copies the internal std::vector object. That's a performance issue, not a correctness issue.

There are actually two performance issues here. The first is that the constructor default constructs the B subobject, then assigns to it. That's wasteful. To fix that:

A::A(A&& other) : B(other.B) {
}

The second is that a move constructor is allowed to steal from the other object. To do that, the implementation should move from the B subobject:

A::A(A&& other) : B(std::move(other.B)) {
}

Finally, to answer the question in the title, std::move works just fine with types that aren't movable. All it does is convert an lvalue to an rvalue; non-movable types can (usually) be copied from rvalues, so unless you're dealing with a very perverse type, just use std::move on pretty much everything in the object. (It might look strange to move an int value, but it's harmless).