When will c++11 perform move automatically when std::move is not explicitly used?

Question

If I have a struct in which I did not provide any copy and move constructor:

struct MyStruct {
  MyStruct() { // this is the only function
    ...
  }
  ...
};

then if I do the following:

std::vector<MyStruct> vec;
...
vec.push_back(MyStruct());

instead of using std::move() like the followings:

vec.push_back(std::move(MyStruct()));

Will c++11 smartly do the move for my temporary variable? Or, how can I make sure it is a move instead of a copy?

Answer 1

In C++11 std::vector::push_back will use a move constructor if passed an rvalue (and a move constructor exists for the type), but you should also consider using std::vector::emplace_back in such situations; std::vector::emplace_back will construct the object in place rather than moving it.

Answer 2

Will c++11 smartly do the move for my temporary variable? Or, how can I make sure it is a move instead of a copy?

It depends. This

vec.push_back(MyStruct());

will bind to

std::vector<MyStruct>::push_back(MyStruct&&);

but whether the rvalue passed is moved or copied depends fully on whether MyStruct has a move copy constructor (likewise for move assignment).

It will make absolutely no difference if you call

vec.push_back(std::move(MyStruct()));

because MyStruct() is already an rvalue.

So it really depends on the details of MyStruct. There is simply not enough information in your question to know if your class has move constructor.

These are the conditions that must be met for a class to have an implicitly generated move constructor:

• no user-declared copy constructors
• no user-declared copy assignment operators
• no user-declared move assignment operators
• no user-declared destructors

Of course, you can always provide your own if any of these conditions are not met:

MyStruct(MyStruct&&) = default;

Answer 3

Because the MyStruct() will create an rvalue the T && overload will be called.

It's actually very easy to verify (demo):

#include <iostream>
struct A{ int x; };

void  foo(A &&x){ std::cout<<"&&" <<std::endl; }

void  foo(A &x){ std::cout<<"&" <<std::endl; }

int main() {
    foo(A()); // prints &&
    A a;
    foo(a); // prints &
    return 0;
}

---

To clarify: I didn't mention anything about move constructor because one can have an explicitly deleted move constructor and still the T && will be invoked.

E.g (demo):

#include <iostream>
struct A{ int x; A() = default; A(const A& ) = default; A(A&&) = delete; };
/*                                                                  ^
                                                            no move ctor */
void  foo(A &&x){ std::cout<<"&&" <<std::endl; }

void  foo(A &x){ std::cout<<"&" <<std::endl; }

int main() {
    foo(A()); //still prints &&
    A a;
    foo(a);
    return 0;
}

As I said before this is because it's an rvalue...

Answer 4

Yes, it is going to use push_back( T&& value ), and move the value.

Answer 5

If the type is movable then it definitely will be. In general standard-complying compiler should always choose move semantics to copy semantics if such are available.