1.1.9.6 move copy and assignment

• copy ctor will copy a obj inside of function, So all the knowledge discussed in previous section can be used to help you understand copy ctor. A better method is overload function to deal with lvalue and rvalue separately.
• Basic copy ctor syntax explanation:
   class obj = 2 //same as class obj(2) 
                      // call single argument ctor 
   
   obj =2         //call assignment operator 
   
   class obj1 = obj2 // call  copy ctor 
                            // not call assignment operator 
   
   obj1 = obj2         //call assignment operator 
   
   class obj1 = obj2+obj3   //call move ctor 
   //if you dont’ have move ctor, It will call copy ctor 
   
   obj1 = obj2+obj3 //call move assignment operator  if you define.
• Typically, if you class allocate a lot of allocated resource (new, or vector, or sth else). You should implement two copy ctor A few explanations are below:
  1. Not move copy ctor will steal resource automatically, you need to coding it by your self.
  2. You can’t steal in normal ctor. because, It must keep origin obj intact. You can steal when Foo(f1+f2), but when you used Foo(f1). It will destory f1.
  3. Without move copy ctor, normal copy ctor will treat Foo f = f1+f2 and Foo f = f1 the same way.
  4. With move copy ctor, normal copy ctor deal with Foo f = f1, and move deal with Foo f = f1+f2, for f1+f2, you can steal resource, because nobody need to use f1+f2 later any more.
  5. In move ctor, always set other.ptr = nullptr;
  6. No const qualifier in move ctor and move assignment
     Foo::Foo(const Foo & foo){ 
       while(ptr++;) 
         ptr[i] = foo.ptr[i]  //expensive copy 
     } 
      
     Foo::Foo(Foo && other){ //no const here 
        ptr = other.ptr;  //efficient move(steal) 
       other.ptr = nullptr; 
     } 
      
     Foo& Foo::operator=(Foo&& other){ 
        delete[] ptr; 
        ptr = other.ptr;  //efficient move(steal) 
        other.ptr = nullptr; 
        return *this; 
     }
• In below examples, Foo obj1=obj2+obj3. if you don’t have move ctor, In operator + function, a temp obj is produced, and when operator+ function return, another temp obj temp2 is produced . Then in the end, objtemp2 is passed to ctor, So, ctor is called three times. and copy content is also called three times.
  Foo Foo::operator+( const Foo & f) const { 
      Foo temp = Foo(n+f.n); 
      //copy happen here. 
      return temp; 
  } 
   
  Foo obj1=obj2+obj3  // three ctor called with move ctor
• If you have move ctor. In operator + function, a temp objtemp1 is produced, When return objtemp1, It will not produce objtemp2. (becasue objtemp1 is rvalue.) then objtemp1 is passed to move ctor. In side move ctor, the resource address has been move to new obj1. Just one temp objtemp1 and one actual copy happen. ( just new pointer = old pointer; and old pointer = NULL).
• Move ctor and move assignment work with rvalue, What if you want to use them with lvalues? You can call std::move function, It will call you move ctor or assignment to "move" resource, not "copy" resource.
  Foo choices[10]; 
  Foo best; 
  best = choices[3]; 
  //I don’t want to keep choices after I pick up what I want 
  //here, It will call normal move assignment, 
  //because choices[3] is not rvalue. 
   
  best = std::move(choices[3]); 
  //It will call move assignment