Copy constructor and move constructor has the same run time and move constructor is not being called

Question

I have a ArrayWrapper class which implements both move and copy constructor.

I have 2 Questions.

1. You can see that in my code, the copy constructor ArrayWrapper (ArrayWrapper& other) is exactly same as move constructor ArrayWrapper (ArrayWrapper&& other)!? Both works just the same and has the same elapsed time. (I commented out the original copy constructor) How can the copy and move constructor use the same code and still work?

2. The code actually isn't hitting the move constructor (I suspect this is why my first question works), I put a comment in both functions, and the output does not show that the move constructor is being called, even though I am passing an rvalue reference ArrayWrapper d3(ArrayWrapper(10000000));. What am I doing wrong?

   #include <bits/stdc++.h>
   #include <chrono> 
   using namespace std;
   using namespace std::chrono; 
   class ArrayWrapper
   {
   public:
       ArrayWrapper ()
           : _p_vals( new int[ 64 ] )
           , _size( 64 )
       {
           cout<<"?"<<endl;
       }
       ArrayWrapper (int n)
           : _p_vals( new int[ n ] )
           , _size( n )
       {
       }
       ArrayWrapper (ArrayWrapper&& other)
           : _p_vals( other._p_vals  )
           , _size( other._size )
       {
           cout<<"Move"<<endl;
           other._p_vals = NULL;
           other._size = 0;
       }
   
       ArrayWrapper (ArrayWrapper& other)
           : _p_vals( other._p_vals  )
           , _size( other._size )
       {
           cout<<"Copy constructor"<<endl;
           other._p_vals = NULL;
           other._size = 0;
       }
       /*
       // copy constructor
       ArrayWrapper (const ArrayWrapper& other)
           : _p_vals( new int[ other._size  ] )
           , _size( other._size )
       {
           for ( int i = 0; i < _size; ++i )
           {
               _p_vals[ i ] = other._p_vals[ i ];
           }
       }
       */
       void generate(){
           for(int i=0; i<_size; i++){
               _p_vals[i] = i;
           }
       }
       ~ArrayWrapper ()
       {
           delete [] _p_vals;
       }
       void print(){
           for(int i=0; i<_size;i++){
               cout<<_p_vals[i]<<" ";
           }
           cout<<endl;
       }
   
   private:
       int *_p_vals;
       int _size;
   };
   
   int main(){
       auto start = high_resolution_clock::now();
       ArrayWrapper d(10000000);
       ArrayWrapper d2(d); //deep copy
       auto stop= high_resolution_clock::now();
       auto duration = duration_cast<microseconds>(stop - start); 
       cout << duration.count() << endl; 
   
       auto start2 = high_resolution_clock::now(); 
       ArrayWrapper d3(ArrayWrapper(10000000)); //shallow copy
       auto stop2 = high_resolution_clock::now(); 
       auto duration2 = duration_cast<microseconds>(stop2 - start2); 
       cout << duration2.count() << endl;
   
   }
   

Answer 1

Both works just the same ... How can the copy and move constructor use the same code and still work?

The body of the function does the same thing, so it works the same way.

Regarding your implication that the copy constructor "works": It is highly non-idiomatic for a copy constructor to modify the operand. Many would agree that it "works" in a wrong way.

P.S. There used to be a smart pointer in the standard library called std::auto_ptr which took ownership of pointer passed to the copy constructor. It was an attempt to implement unique pointer before move semantics existed. There is no longer any reason to do that, since we do have move constructors. std::auto_ptr was removed from the standard for a good reason.

The code actually isn't hitting the move constructor ... What am I doing wrong?

You're initialising from a prvalue expression of the same type. d3 is constructed directly using the initialiser expression of ArrayWrapper(10000000) without any temporary object. In other words, only ArrayWrapper (int n) is used; not the move constructor.

Prior to C++17, there would be a temporary object which would be moved from as far as the abstract machine is concerned, but even then, the move can be elided, which means the same as above (no temporary, no move) except it is an optimisation that is merely allowed, and not mandated by the standard.

What you're doing wrong is expecting there to be a move, or that the move is guaranteed to have side effects.

Answer 2

You can see that in my code, the copy constructor ArrayWrapper (ArrayWrapper& other) is exactly same as move constructor ArrayWrapper (ArrayWrapper&& other)!? Both works just the same and has the same elapsed time. (I commented out the original copy constructor) How can the copy and move constructor use the same code and still work?

The only time the copy constructor and move constructor can be exactly the same is when you are dealing with types that are only copyable (or to move them is to get a copy). This is not what you have. In

ArrayWrapper (ArrayWrapper& other)
    : _p_vals( other._p_vals  )
    , _size( other._size )
{
    cout<<"Copy constructor"<<endl;
    other._p_vals = NULL;
    other._size = 0;
}

You basically have an lvalue move constructor. If you were to print the size of d after ArrayWrapper d2(d); you would get 0 since you steal its data. This isn't making a copy and would really confuse a lot of programmers since it does something totally unexpected. You need to use the code you have in ArrayWrapper (const ArrayWrapper& other) if you really want a copy to be made.