1.1.9.3 uniqu_ptr

• If a program attempts to assign one unique_ptr to another. The compiler allows it if the source object is a temporary rvalue and disallows it if the source object has some duration:
  unique_ptr<string> pu1(new string("hello␣world") ); 
   
  unique_ptr<string> pu2(pu1);  // not allow 
  pu2 = pu1 // not allow, pu1 is not temporary 
   
  pu2 = uqique_ptr<string>(new string("yo") ); //OK 
   
  uqique_ptr<string> fun(){ 
  return unique_ptr<string> temp(new string("yan"); 
  } 
  pu2 = fun(); //OK
• If you really want to transfer ownership between two uniqu_ptr, you have to use move.
  unique_ptr<string> pu1(new string("hello␣world") ); 
  unique_ptr<string> pu2; 
   
  unique_ptr<T> pu2 = std::move(pu1); 
  // Okay, resource now stored in pu2
• You almost always use make_unique to create an object to be initially owned by a unique_ptr.
  void sink( unique_ptr<widget>, unique_ptr<gadget> ); 
  sink( make_unique<widget>(new ...), 
  make_unique<gadget>(new ...) );  // exception-safe
• Unique_ptr has new [] version.
  unique_ptr<double []>  pda(new double(5) ); 
  // it will call delete []
• You can store unique_ptr objects in an STL container providing you don’t invoke methods or algorithm, such as copy(), that copy or assign one unique_ptr to another. see effective stl item 8.
  bool compare_by_uniqptr( 
                 const unique_ptr<SomeLargeData>& a, 
                 const unique_ptr<SomeLargeData>& b) { 
      return a->id < b->id; 
  } 
   
  sort(vec_byuniqptr.begin(), vec_byuniqptr.end(), 
  compare_by_uniqptr);
  typedef std::unique_ptr<int> unique_t; 
  typedef std::vector< unique_t > vector_t; 
   
  vector_t vec2(5, unique_t(new Foo));     // Error (Copy) 
  vector_t vec3(vec1.begin(), vec1.end()); // Error (Copy) 
  std::copy(vec1.begin(), vec1.end(), 
            std::back_inserter(vec2)); // Error (copy) 
   
  vector_t vec3(make_move_iterator(vec1.begin()), 
                   make_move_iterator(vec1.end())); //Ok 
   
  std::sort(vec1.begin(), vec1.end()); 
  // OK, because using Move Assignment Operator
• If the program uses more than one pointer to an object, shared_ptr is your choice. Such as you have two objects that contain pointers to the same third object. Or you may have an STL container of pointers.