1.1.10.3 Smart pointer Basic knowledge

• A simple auto_ptr source code: You can learn how to overload operator*() and operator->().
  template <class T> class auto_ptr{ 
      T* ptr; 
  public: 
      explicit auto_ptr(T* p = 0) : ptr(p) {} 
      ~auto_ptr()                 {delete ptr;} 
      ____________________________________T& operator*()     {return *ptr;} 
      ____________________________________T* operator->()    {return ptr;} 
      // ... 
  }; 
   
  auto_ptr<int> aupr; 
  //aupr is nullptr even you don’t initialize it.
• Why do we need smart pointer?
  1. "Just remember" is seldom the best solution! So we need smart pointer to perform delete operator automatically.
  2. When throw an exception, or return in the middle of code. delete will not be invoked at all, It will cause memory leaking. When you use smart pointer, If an exception is thrown in the middle of fun, there will no be memory leak.
     void methodA() { 
        unique_ptr<int> buf(new int[256]); 
      
        int result = fillBuf(buf)) 
        if(result == -1) 
           return; 
     }
  3. smart pointer is nullptr default if you don’t initialize. You avoid wild pointer problem.
  4. smart pointer can manage exclusive ownership or shared ownership automatically.
• There are four kinds of smart pointer: auto_ptr, unique_ptr, shared_ptr and weak_ptr. But only unique_ptr and shared_ptr are recommended to use. auto_ptr is now deprecated, and should not be used in new code. When you get a chance, try doing a global search-and-replace of auto_ptr to unique_ptr in your code base. weak_ptr is mainly used for observer, you can always use raw pointer or reference for this purpose. Raw pointer can’t check if pointee object is still valid, weak_ptr can accomplish this task.
• Why auto_ptr not recommended? 1) When you assign targetP = sourceP, it will cause sourceP set to be NULL, It will cause trouble when you use sourceP in the future. 2)You can’t create container includes auto_ptr, compiler prohibit you doing so!
  auto_ptr<string> ps (new string("hello␣world") ); 
  auto_ptr<string> ps1; 
  ps1 = ps;   // ps will be set null. 
  ps->size() // it will crash the application. 
   
  auto_ptr<string> parray[5]; //compiling error. 
  auto_ptr<string> ps = parray[2]; 
  //parray[2] will be set null;
• When you construct a smart pointer, you must use 1) a pointer and 2) this pointer must be produced by new. You can’t build smart pointer by address operator. such as unique_ptr<double> ptr(&int); Why? because smart pointer will call delete when it is out of scope. delete operator has to be used on pointer produced by new operator.
• Obtain the raw pointer (get), to relinquish control of the pointed object (release), and to replace the object it manages (reset).
  string * cp = new string("hello␣world"); 
  shared_ptr<string> ps(cp); 
  string * cp1 = ps.get(); //use get() get normal pointer.
• Smart pointer has bool operator, you can use if to test if it’s nullptr directly.
   std::unique_ptr<int> ptr(new int(42)); 
   if (ptr) std::cout <<  *ptr << ’\n’; 
   ptr.reset(); 
   if (ptr) std::cout <<  *ptr << ’\n’;
• Smart pointer and const:
  shared_ptr<T> p;        ---> T * p; 
  const shared_ptr<T> p;   ---> T * const p; 
  shared_ptr<const T> p;   ---> const T * p; 
  const shared_ptr<const T> p; ---> const T * const p;
• Smart pointer is used mainly for ownership, It doesn’t support Inheritance well. Don’t use smart pointer when you want to use in polymorphous.