手撕c++ unique_ptr（字节跳动手写算法）

#include <iostream>
#include <memory>

using namespace std;

namespace smart_pointer
{

template <typename T>
struct defaultDeleter {
  void operator()(const T *ptr) {
    if(ptr) {
    	delete ptr;
    	ptr = nullptr;
    }
  }
};

template <typename T, typename Deleter=defaultDeleter<T> >
class unique_ptr {
public:
  unique_ptr();
  unique_ptr(T *ptr);
  unique_ptr(unique_ptr &&p); //移动构造
  ~unique_ptr();

//non-copyable
private:
  unique_ptr(const unique_ptr &p);
  unique_ptr &operator=(const unique_ptr &p);

public:
  T& operator* ();
  T* operator-> ();
  unique_ptr &operator=(unique_ptr &&p); //移动赋值，右值 
  operator bool() const;

  //返回原始指针
  T* get() const;
  //返回指针，释放所有权
  T* release();
  //替换被管理的对象
  void reset(T *ptr);
  //交换被管理的对象
  void swap(unique_ptr &p);

private:
  T *ptr;
};

template <typename T, typename Deleter>
unique_ptr<T, Deleter>::unique_ptr()
 : ptr(nullptr)
{}

template <typename T, typename Deleter>
unique_ptr<T, Deleter>::unique_ptr(T *_ptr)
 : ptr(_ptr) 
{}

//移交所有权
template <typename T, typename Deleter>
unique_ptr<T, Deleter>::unique_ptr(unique_ptr &&p)
 : ptr(p.ptr) {
  p.ptr = nullptr;
}

template <typename T, typename Deleter>
unique_ptr<T, Deleter>::~unique_ptr()
{
  Deleter()(ptr);
  cout << "unique_ptr dctor" << endl;
}

template <typename T, typename Deleter>
T& unique_ptr<T, Deleter>::operator* ()
{
  return *ptr;
}

template <typename T, typename Deleter>
T* unique_ptr<T, Deleter>::operator-> ()
{
  return ptr;
}

template <typename T, typename Deleter>
unique_ptr<T, Deleter> &unique_ptr<T, Deleter>::operator=(unique_ptr &&p)
{
  std::swap(ptr, p.ptr);
  return *this;
}

template <typename T, typename Deleter>
unique_ptr<T, Deleter>::operator bool() const
{
  return ptr != nullptr;
}

template <typename T, typename Deleter>
T* unique_ptr<T, Deleter>::get() const 
{
  return ptr;
}

template <typename T, typename Deleter>
T* unique_ptr<T, Deleter>::release()
{
  T *pointer = ptr;
  ptr = nullptr;
  return pointer;
}

template <typename T, typename Deleter>
void unique_ptr<T, Deleter>::reset(T *_ptr)
{
  unique_ptr<T, Deleter>().swap(*this);

  ptr = _ptr;
}

template <typename T, typename Deleter>
void unique_ptr<T, Deleter>::swap(unique_ptr &p)
{
  std::swap(ptr, p.ptr);
}

}; //namespace smart_pointer

int main(int argc, char *argv[])
{
  {
    smart_pointer::unique_ptr<int> p(new int(10));
    //smart_pointer::unique_ptr<int> p1 = p; //编译不过的
    //mart_pointer::unique_ptr<int> p2(p); //编译不过的
    cout << *p << endl;
    
    int *p3 = p.release();
    if(!p) cout << "p is released" << endl;
    cout << *p3 << endl;
    delete p3; //手动释放

    p = smart_pointer::unique_ptr<int>(new int(11)); //移动赋值
    smart_pointer::unique_ptr<int> p4(new int(12));
    p4.swap(p);
    cout << *p << endl;

 	p.reset(new int(13));
 	cout << *p << endl;
  }

  return 0;
}