1.1.10.8 smart pointer Scenario

• Smart pointer general guides:
  1. You must ensure that there is only one manager object for each managed object. You do this by writing your code so that when an object is first created, it is immediately given to a shared_ptr to manage, and any other shared_ptrs or weak_ptrs that are needed to point to that object are all directly or indirectly copied or assigned from that first shared_ptr. The customary way to ensure this is to write the new object expression as the argument for a shared_ptr constructor, or use the make_shared function template described below.
  2. The exception to this immediate assignment rule is things like factory methods that return a plain pointer to the object they create – in this case however, the callee still should generally be immediately assigning this returned object to a shared_ptr or unique_ptr. Methods should return a plain-pointers when it is up to the caller to handle ownership of the object(exclusive ownership or shared ownership).
  3. Methods can take plain-pointers as their arguments for just observe it. Or use smart pointer to transfer or get ownership.
     ObserveFun(Foo* p); 
     ObserveFun(smart_pointer.get() ); 
     ObserveFun(unique_ptr<Foo> &p); 
     //Not use very often, can be used as fun_obj 
     // in a container of unique_ptr. 
      
     UniqueFun(unique_ptr<Foo> p); 
     UniqueFun(make_unique_ptr<Foo>(new Foo() )); //get ownership 
     UniqueFun(move(other_unique_ptr) )  //transfer ownership 
      
     SharedFun(shared_ptr<Foo> p);
  4. If you want to get the full benefit of smart pointers, your code should avoid using raw pointers to refer to the same objects; otherwise it is too easy to have problems with dangling pointers or double deletions. In particular, smart pointers have a get() function that returns the pointer member variable as a built-in pointer value. This function is rarely needed. As much as possible, leave the built-in pointers inside the smart pointers and use only the smart pointers.
• Three policy of smart pointer usage:
  1. Owership policy: use smart pointer.
  2. Observer Policy : use raw pointer, reference or weak_ptr
  3. Nullity Policy: Not allow nullptr, prefer to use reference. prefer reference than pointer
• When you want to use raw pointer in STL container, There are two things you need to consider:
  1. Be wary of remove-like algorithms on containers of pointers. "effective STL item 33"
  2. When using containers of newed pointers, remember to delete the pointers before the container is destroyed. "effective STL item 7". All these two problems can be resolved by using smart pointer.
• Observer pointer,observing pointers are pointers which do not keep the pointed object alive raw pointers are bad when used for performing manual memory management, i.e. new and delete. When used purely as a means to achieve reference semantics and pass around non-owning, observing pointers, there is nothing intrinsically dangerous in raw pointers. Just not to dereference a dangling pointer
  observe(subject * s1) 
  // subject is a class ovserver is function. 
  //just use raw pointer subject, use weak_ptr or raw pointer. 
  //observer doesn’t have owner policy and 
  // life time policy with subject
• Function example 1: Inside a function
  1. If you don’t want to create dynamically or large array, don’t use new. Just use local auto object.
  2. When you have to use new, and this function has Ownership of pointer, means that they have the same life time, use unique_ptr.
  fun(){ 
  Foo fo(); 
  // it make obj directly, 
  //when you don’t need dynamic. 
   
  if(input == "Foo") 
         uniqu_ptr<Foo> up(new Foo() ); 
  //When you need new, use uniqu_ptr 
  }
• Function example 2 : argument of a function.
  1. As a parameter, pass it to a function. if you don’t want to create dynamicly or large array, don’t use new. Just use reference.
  2. If you have to use new, use uniqu_ptr & as argument. Here, You just want to observe sth, no ownership transfer
  3. If you want to transfer ownership to callee from caller, use uniqu_ptr, and use move.
  4. If you want to shared ownership to callee from caller, use shared_ptr
  Foo *fo = new Foo();  //bad smell here. 
  fun(Foo * p); 
  delete fo; 
   
  fun(Foo &p); //use reference to improve efficiency 
   
  uniqu_ptr<Foo> up(new Foo() ); 
  fun(uniqu_ptr<Foo>& up); //use reference here 
   //to avoid copy, uniqu_ptr can’t copy 
   
  fun(uniqu_ptr<Foo> down);  //prototype 
  fun(std::move(up) );
• Function example3: return from function.
  1. As a function return value. if you don’t want to create dynamically or large array, don’t use new. Don’t use reference refer to a local object created inside of fun.
  2. If you have to use New, and you want to transfer Ownership from callee to caller. You should use unique_ptr.
  3. If there is no clear single owner, store and return shared_ptr.(in this example, caller of fun() is single owner, so use unique_ptr)
  Foo* fun(){   //old c style. 
  ........ 
  return new Foo(); 
  } 
   
  unique_ptr<Foo> fun(){  // this is better. 
  ........ 
  return unique_ptr<Foo>(new Foo()) ; 
  }
• Below use shared_ptr, because Server is public used, and no single owner.
  shared_ptr<Server> buildNewServer(){  // this is better. 
  return shared_ptr<Foo>(new Foo()) ; 
  } 
   
  shared_ptr<Server> serverForClass1 = buildNewServer(); 
  shared_ptr<Server> serverForClass2  = serverForClass1;