Understanding object copying when containers are assigned in c++

Question

I am trying to understand the behavior of object copying and object move when containers are involved. Here is a sample code i wrote.

#include<memory>
#include<iostream>
#include<vector>
using namespace std;
class X{
  int val;
public:
  X(int i):val(i){cout<<"constructor X"<< val <<endl;}
  X(){cout<<"constructor X"<< val <<endl;}
  X(const X &a) {cout<<"copy constructor X"<< val <<endl;}
  X(X &&a) {cout<<"move constructor X"<< val <<endl;}
  ~X(){cout<<"Distructor X"<< val << endl;}
  X& operator = (X a){ cout<<"Assignment operator"<<endl; return a;}
  void do1(){cout<<"Do"<<endl;}
};

vector<X> container_copy(){
  vector<X> a1(10);
  return a1;
}

main(){
  vector<X> b;

  vector<X> a = container_copy(); //#1 .
  b = a; // #2

  cout<<"Done"<<endl;
}

here is the sample output i got using

constructor X0
constructor X0
constructor X0
copy constructor X0
copy constructor X0
copy constructor X0
Done
Distructor X0
Distructor X0
Distructor X0
Distructor X0
Distructor X0
Distructor X0

Here is my queries.

1. Why is the move constructor not called for statement marked #1

2. Why is the copy constructor called instead of assignment operator for #2

I am using following command for compiling under gcc

g++ <file_name>.cpp --std=c++11

Answer 1

Why is the move constructor not called for statement marked #1

The vector itself isn't moved because of the return value optimisation. The function constructs its return value directly in the caller space, so there's no moving or copying. The vector elements are not moved regardless. Elements are never moved when the vector itself is copy- or move-conctructed.

Why is the copy constructor called instead of assignment operator for #2

Container aasignment works like this: throw away old elements, then copy new elements in. At the second stage the container has no elements to assign to, thus no assignment. Why throw old elements away? For consistency: the number of existing elements may be larger or smaller than the number of new elements, and we don't want complicated implementation and inconsistent results for this operation.

Answer 2

Taking your two questions in order:

In the first case, your element move-constructor will never be fired in this context, no matter what. Given your output, the function call is undergoing RVO. I.e. a is what is actually constructed as if it were the vector in the function. Even without RVO, there still wouldn't be a need for element-moving. Rather, you would see something similar to your second case which I describe next

In the second case, you asked why there were no assignment operators invoked. Copy construction is invoked because there is nothing to assign to (much less move to), so there won't be element moving going on here either. b is initially empty, remember? The result of b = a will simply reserve space for the elements in a, then then copy-construct each element out of a to finish off the b vector. No moves are required (nor wanted), of either your elements nor any vectors. You asked for a copy, and that's what you're getting.

Worth noting, had you asked for a move-assignment of the vector rather than a copy-assignment:

b = std::move(a);

you still would not get element-wise move-construction. The vector itself would be moved. If b were previously populated, those contents would be destroyed and the result would be b taking ownership of a's elements.

In short, there is zero use for a move-constructor for the given code. It will never be called, because it should never be called.

Answer 3

Due to return value optimisation there is probably no copy/move involved in calling container_copy.

If you compile with optimisations turned on the function is almost certainly small enough to be inlined so your main function would become and even return value optimisation is unnecessary:

main(){
  vector<X> b;

  vector<X> a(10); //#1 .
  b = a; // #2

  cout<<"Done"<<endl;
}

#2 is calling the copy constructors as it is the vector itself which is being assigned which internally will be doing something like this (roughly, this code isn't optimal but just to give you the idea):

std::vector<X> operator = ( const std::vector<X>& other )
{
   clear();
   for (const auto& x : other)
   {
      push_back(X(x)); // actually its probably doing a placement new rather than push_back which would result in an additional copy
   }
}