自己动手实现一个智能指针

这样，我们自然而然利用了指针的转换特性：现在 smart_ptr 可以移动给 smart_ptr，但不能移动给 smart_ptr。

不正确的转换会在代码编译时直接报错。

需要注意，上面这个构造函数不被编译器看作移动构造函数，因而不能自动触发删除拷贝构造函数的行为。

如果我们想消除代码重复、删除移动构造函数的话，就需要把拷贝构造函数标记成 = delete 了（见“拷贝构造和赋值”一节）。

不过，更通用的方式仍然是同时定义标准的拷贝 / 移动构造函数和所需的模板构造函数。

下面的引用计数智能指针里我们就需要这么做。

如果提供了移动构造函数而没有同步提供拷贝构造函数，则后者被默认删除。

但是上面这个例子不算是提供了移动构造函数，所以需要手动标明删除拷贝构造函数。

unique_ptr 算是一种较为安全的智能指针了。

因为unique_ptr一个对象只能被一个只能指针拥有，所以它拥有以下优点：

1.不会产生内存泄漏

2.不会出现重复删除内存的情况

3.不会出现源对象在发生异常时候损坏的情况

但是，一个对象只能被单个 unique_ptr 所拥有，这显然不能满足所有使用场合的需求。

一种常见的情况是，多个智能指针同时拥有一个对象；当它们全部都失效时，这个对象也同时会被删除。

这也就是 shared_ptr 了。

unique_ptr 和 shared_ptr 的主要区别如下图所示：

 多个不同的 shared_ptr 不仅可以共享一个对象，在共享同一对象时也需要同时共享同一个计数。

当最后一个指向对象（和共享计数）的 shared_ptr 析构时，它需要删除对象和共享计数。

我们下面就来实现一下。

我们先来写出共享计数的接口：

class shared_count {
public:
  shared_count();
  void add_count();
  long reduce_count();
  long get_count() const;
};

这个 shared_count 类除构造函数之外有三个方法：一个增加计数，一个减少计数，一个获取计数。

注意上面的接口增加计数不需要返回计数值；但减少计数时需要返回计数值，以供调用者判断是否它已经是最后一个指向共享计数的 shared_ptr 了。

我们先来实现一个简单化的版本：

class shared_count {
public:
  shared_count() : count_(1) {}
  void add_count()
  {
    ++count_;
  }
  long reduce_count()
  {
    return --count_;
  }
  long get_count() const
  {
    return count_;
  }

private:
  long count_;
};

现在我们可以实现我们的引用计数智能指针了。

首先是构造函数、析构函数和私有成员变量：

template 
class smart_ptr {
public:
  explicit smart_ptr(T* ptr = nullptr)
    : ptr_(ptr)
  {
    if (ptr) {
      shared_count_ =
        new shared_count();
    }
  }
  ~smart_ptr()
  {
    if (ptr_ &&
      !shared_count_
         ->reduce_count()) {
      delete ptr_;
      delete shared_count_;
    }
  }

private:
  T* ptr_;
  shared_count* shared_count_;
};

构造函数跟之前的主要不同点是会构造一个 shared_count 出来。

析构函数在看到 ptr_ 非空时（此时根据代码逻辑，shared_count 也必然非空），需要对引用数减一，并在引用数降到零时彻底删除对象和共享计数。

由于因为复制运算符是利用拷贝构造和swap实现的，所以我们需要一个新的 swap 成员函数，并更新一下拷贝构造和移动构造函数。

除复制指针之外，对于拷贝构造的情况，我们需要在指针非空时把引用数加一，并复制共享计数的指针。

对于移动构造的情况，我们不需要调整引用数，直接把 other.ptr_ 置为空，认为 other 不再指向该共享对象即可。

由于模板是用来实例化出具体的类，实例化出来的类就像我们平时写的不具有模板参数的类一样，彼此之间是不同，这与类的派生是不同的，因此不具有天然的友元关系。

我们需要在 smart_ptr 的定义中显式声明：

  template 
  friend class smart_ptr;

此外，我们之前的实现（类似于单一所有权的 unique_ptr ）中用 release 来手工释放所有权。

在目前的引用计数实现中，它就不太合适了，应当删除。

但我们要加一个对调试非常有用的函数，返回引用计数值。

定义如下：

  long use_count() const
  {
    if (ptr_) {
      return shared_count_
        ->get_count();
    } else {
      return 0;
    }
  }

现在，我们已经完成了一个比较完整的引用计数智能指针的实现。

我们可以用下面的代码来验证一下它的功能正常：

class shape {
public:
  virtual ~shape() {}
};

class circle : public shape {
public:
  ~circle() { puts("~circle()"); }
};

int main()
{
  smart_ptr ptr1(new circle());
  printf("use count of ptr1 is %ld\n",
         ptr1.use_count());
  smart_ptr ptr2;
  printf("use count of ptr2 was %ld\n",
         ptr2.use_count());
  ptr2 = ptr1;
  printf("use count of ptr2 is now %ld\n",
         ptr2.use_count());
  if (ptr1) {
    puts("ptr1 is not empty");
  }
}

这段代码的运行结果是：

use count of ptr1 is 1
use count of ptr2 was 0
use count of ptr2 is now 2
ptr1 is not empty~circle()

上面我们可以看到引用计数的变化，以及最后对象被成功删除

下面我给出了一个完整的 smart_ptr 代码列表：

#include   // std::swap

class shared_count {
public:
  shared_count() noexcept
    : count_(1) {}
  void add_count() noexcept
  {
    ++count_;
  }
  long reduce_count() noexcept
  {
    return --count_;
  }
  long get_count() const noexcept
  {
    return count_;
  }

private:
  long count_;
};

template 
class smart_ptr {
public:
  template 
  friend class smart_ptr;

  explicit smart_ptr(T* ptr = nullptr)
    : ptr_(ptr)
  {
    if (ptr) {
      shared_count_ =
        new shared_count();
    }
  }
  ~smart_ptr()
  {
    if (ptr_ &&
      !shared_count_
         ->reduce_count()) {
      delete ptr_;
      delete shared_count_;
    }
  }

  smart_ptr(const smart_ptr& other)
  {
    ptr_ = other.ptr_;
    if (ptr_) {
      other.shared_count_
        ->add_count();
      shared_count_ =
        other.shared_count_;
    }
  }
  template 
  smart_ptr(const smart_ptr& other) noexcept
  {
    ptr_ = other.ptr_;
    if (ptr_) {
      other.shared_count_->add_count();
      shared_count_ = other.shared_count_;
    }
  }
  template 
  smart_ptr(smart_ptr&& other) noexcept
  {
    ptr_ = other.ptr_;
    if (ptr_) {
      shared_count_ =
        other.shared_count_;
      other.ptr_ = nullptr;
    }
  }
  template 
  smart_ptr(const smart_ptr& other,
            T* ptr) noexcept
  {
    ptr_ = ptr;
    if (ptr_) {
      other.shared_count_
        ->add_count();
      shared_count_ =
        other.shared_count_;
    }
  }
  smart_ptr&
  operator=(smart_ptr rhs) noexcept
  {
    rhs.swap(*this);
    return *this;
  }

  T* get() const noexcept
  {
    return ptr_;
  }
  long use_count() const noexcept
  {
    if (ptr_) {
      return shared_count_
        ->get_count();
    } else {
      return 0;
    }
  }
  void swap(smart_ptr& rhs) noexcept
  {
    using std::swap;
    swap(ptr_, rhs.ptr_);
    swap(shared_count_,
         rhs.shared_count_);
  }

  T& operator*() const noexcept
  {
    return *ptr_;
  }
  T* operator->() const noexcept
  {
    return ptr_;
  }
  operator bool() const noexcept
  {
    return ptr_;
  }

private:
  T* ptr_;
  shared_count* shared_count_;
};

template 
void swap(smart_ptr& lhs,
          smart_ptr& rhs) noexcept
{
  lhs.swap(rhs);
}

template 
smart_ptr static_pointer_cast(
  const smart_ptr& other) noexcept
{
  T* ptr = static_cast(other.get());
  return smart_ptr(other, ptr);
}

template 
smart_ptr reinterpret_pointer_cast(
  const smart_ptr& other) noexcept
{
  T* ptr = reinterpret_cast(other.get());
  return smart_ptr(other, ptr);
}

template 
smart_ptr const_pointer_cast(
  const smart_ptr& other) noexcept
{
  T* ptr = const_cast(other.get());
  return smart_ptr(other, ptr);
}

template 
smart_ptr dynamic_pointer_cast(
  const smart_ptr& other) noexcept
{
  T* ptr = dynamic_cast(other.get());
  return smart_ptr(other, ptr);
}