1.1.8.3 rvalue reference

• Rvalue references allow a function to branch at compile time (via overload resolution) on the condition "Am I being called on an lvalue or an rvalue?" It is true that you can overload any function in this manner, as shown above. But in the overwhelming majority of cases, this kind of overload should occur only for copy constructors and assignment operators, for the purpose of achieving move semantics.
  void foo(X& x); // lvalue reference overload 
  void foo(X&& x); // rvalue reference overload 
   
  X x; 
  X foobar(); //return a X obj 
   
  foo(x); // argument is lvalue: calls foo(X&) 
  foo(foobar()); 
  // argument is rvalue: calls foo(X&&)
• How to understand move semantics? Move is not really move a big chunk of data, It just move index of data. just like you move file in the hard disk.
• rvalues denote temporaries or objects that want to look like a temporary. What is so particular about temporaries, is the fact that they will be used in a very limited way: their value will be read once, and they will be destroyed. This is a very useful observation in implementing "move semantics." In other words, "steal resource"
• Typical, 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(f1+f2) and Foo(f1) the same way.
  4. With move copy ctor, normal copy ctor deal with Foo(f1), and move deal with Foo(f1+f2), for f1+f2, you can steal resource, because nobody need to use f1+f2 later any more.
  class Foo{ 
  Foo::Foo(Foo && foo){ 
  ptr = foo.ptr; 
  foo.ptr = nullptr; 
  //steal resource 
  } 
   
  Foo::Foo(const Foo & foo){ 
  For(ptr++;) 
  ptr[i] = foo.ptr[i] 
  //copy source 
  } 
   
  fun(const Foo& f){ 
  } 
   
  fun(foo1+foo2) // will call move ctor once. 
   // in g++, maybe it will call copy ctor in other compiler. 
                    //without move, it will call copy ctor once. 
   
  Foo foo3(foo1+foo2) //will call move ctor twice. 
              //without move, it will call copy ctor twice. 
   
  funNoConst(Foo &f){ 
  } 
  funNoConst(foo1+foo2) //compile error.
• Three kinds of references:
  // 1)lvalue reference. 
  fun(Foo& foo); 
  fun(foo1+foo2) // will not compile 
   
  // 2) const lvaue reference 
  fun(const & foo); 
  fun(foo1+foo2) // will compile, but expensive 
   
  //3) only rvalue reference 
  fun(Foo&& foo); 
  fun(foo1+foo2) // will compile, efficient if you move resource.
• There are three applications for right reference: move (copy) constructor, move assignment and move function
   class::class(class &&f); //move constructor 
   class obj1=obj2+obj3 //or 
   class obj1(obj2+obj3) 
   
   class:class operator=(class &&f) //move assignment 
   obj1=obj2+obj3; 
   
  obj1=std::move(obj2) // move function. use operator = inside
• 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.
  Foo Foo::operator+( const Foo & f) const { 
      Foo temp = useless(n+f.n); 
      //copy happen here. 
      return temp; 
  } 
   
  Foo::Foo(Foo && f) :n(f.n){ 
       pc = f.pc   //steal a address 
       f.pc = NULL; // no actual copy happen here. 
       f.n = 0; 
  } 
  Foo obj1=obj2+obj3  // three ctor called with move ctor
• In previous examples Foo obj1=obj2+obj3. if you don’t have move ctor, In operator + function, a temp objtemp1 is produced, and when operator+ function return, another temp objtemp2 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.
• 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