大多数C++类用三种方法之一管理指针成员
    （1）不管指针成员。复制时只复制指针，不复制指针指向的对象。当其中一个指针把其指向的对象的空间释放后，其它指针都成了悬浮指针。这是一种极端
    （2）当复制的时候，即复制指针，也复制指针指向的对象。这样可能造成空间的浪费。因为指针指向的对象的复制不一定是必要的。
   （3） 第三种就是一种折中的方式。利用一个辅助类来管理指针的复制。原来的类中有一个指针指向辅助类，辅助类的数据成员是一个计数器和一个指针（指向原来的）（此为本次智能指针实现方式）。
     其实，智能指针的引用计数类似于java的垃圾回收机制：java的垃圾的判定很简答，如果一个对象没有引用所指，那么该对象为垃圾。系统就可以回收了。 


#include<iostream>
using namespace std;

// 定义仅由HasPtr类使用的U_Ptr类，用于封装使用计数和相关指针
// 这个类的所有成员都是private，我们不希望普通用户使用U_Ptr类，所以它没有任何public成员
// 将HasPtr类设置为友元，使其成员可以访问U_Ptr的成员
class U_Ptr
{
   friend class HasPtr;
   int *ip;
   size_t use;
   U_Ptr(int *p) : ip(p) , use(1)
   {
      cout << "U_ptr constructor called !" << endl;
   }
   ~U_Ptr()
   {
      delete ip;
      cout << "U_ptr distructor called !" << endl;
   }
};

class HasPtr
{
public:
   // 构造函数：p是指向已经动态创建的int对象指针
   HasPtr(int *p) : ptr(new U_Ptr(p))
   {
      cout << "HasPtr constructor called ! " << "use = " << ptr->use << endl;
   }

   // 复制构造函数：复制成员并将使用计数加1
   HasPtr(const HasPtr& orig) : ptr(orig.ptr)
   {
      ++ptr->use;
      cout << "HasPtr copy constructor called ! " << "use = " << ptr->use<< endl;
   }

   // 赋值操作符
   HasPtr& operator=(const HasPtr&);

   // 析构函数：如果计数为0，则删除U_Ptr对象
   ~HasPtr()
   {
      cout << "HasPtr distructor called ! " << "use = " << ptr->use << endl;
      if (--ptr->use == 0)
         delete ptr;
   }

   // 获取数据成员
   int *get_ptr() const
   {
      return ptr->ip;
   }
   // 修改数据成员
   void set_ptr(int *p) const
   {
      ptr->ip = p;
   }
   // 返回或修改基础int对象
   int get_ptr_val() const
   {
      return *ptr->ip;
   }
   void set_ptr_val(int i)
   {
      *ptr->ip = i;
   }
private:
   U_Ptr *ptr;//指向使用计数类U_Ptr
};
HasPtr& HasPtr::operator = (const HasPtr &rhs)  //注意，这里赋值操作符在减少做操作数的使用计数之前使rhs的使用技术加1，从而防止自我赋值
{
   // 增加右操作数中的使用计数
   ++rhs.ptr->use;
   // 将左操作数对象的使用计数减1，若该对象的使用计数减至0，则删除该对象
   if (--ptr->use == 0)
      delete ptr;
   ptr = rhs.ptr;// 复制U_Ptr指针
   return *this;
}

int main(void)
{
    int *pi = new int(42);
    HasPtr *hpa = new HasPtr(pi);    //构造函数
    HasPtr *hpb = new HasPtr(*hpa);   //拷贝构造函数
    HasPtr *hpc = new HasPtr(*hpb);    //拷贝构造函数
    HasPtr hpd = *hpa;     // 拷贝构造函数

    cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl;
    hpc->set_ptr_val(10000);
    cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl;
    hpd.set_ptr_val(10);
    cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl;
    delete hpa;
    delete hpb;
    delete hpc;

    return 0;
}方案二 为了避免上面方案中每个使用指针的类自己去控制引用计数，可以用一个类把指针封装起来。封装好后，这个类对象可以出现在用户类使用指针的任何地方，表现为一个指针的行为。我们可以像指针一样使用它，而不用担心普通成员指针所带来的问题，我们把这样的类叫句柄类。在封装句柄类时，需要申请一个动态分配的引用计数空间，指针与引用计数分开存储。实现示例如下