智能指针

我们每申请一块动态内存，都必须在某处释放它，如果忘记了，则会造成内存泄露。

 

为了减轻程序员的负担并降低程序内存泄露的风险，有人想了一种办法：不直接调用动态内存的指针，而是通过 类 来封装一下。

因为类有构造函数和析构函数，并且总是成对出现的，我们只要在析构函数中释放掉申请到的动态内存，就安全了。而类的析构函数是系统调用的，不用我们去操心。这就是智能指针的中心思想。

 

甚好，甚强巨。可是，要用这个方法，还要注意几个问题：

1.如果两个智能指针指向同一块儿动态内存，那就有两个析构函数，动态内存就会被删除两遍。

2.如果采用计数器来避免问题1中所遇到的问题，还会面临多个（大于2）智能指针计数器不能同步的问题。

 

其实，解决计数器问题有种经典策略：

定义一个单独的具体类用以封闭使用计数和相关指针：

     // private class for use by HasPtr only
     class U_Ptr {
         friend class HasPtr;
         int *ip;
         size_t use;
         U_Ptr(int *p): ip(p), use(1) { }
         ~U_Ptr() { delete ip; }
     };

     class HasPtr {
     public:
         // HasPtr owns the pointer; pmust have been dynamically allocated
         HasPtr(int *p, int i): ptr(new U_Ptr(p)), val(i) { }

         // copy members and increment the use count
         HasPtr(const HasPtr &orig):
            ptr(orig.ptr), val(orig.val) { ++ptr->use; }
         HasPtr& operator=(const HasPtr&);

         // if use count goes to zero, delete the U_Ptr object
         ~HasPtr() { if (--ptr->use == 0) delete ptr; }
     private:
         U_Ptr *ptr;        // points to use-counted U_Ptr class
         int val;
     };
     
     HasPtr& HasPtr::operator=(const HasPtr &rhs)
     {
         ++rhs.ptr->use;     // increment use count on rhs first
         if (--ptr->use == 0)
              delete ptr;    // if use count goes to 0 on this object, delete it
         ptr = rhs.ptr;      // copy the U_Ptr object
         val = rhs.val;      // copy the int member
         return *this;
     }