手撕c++ shared_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 shared_ptr {
public:
  shared_ptr();
  shared_ptr(T *ptr);
  shared_ptr(const shared_ptr &sp); //拷贝构造
  shared_ptr(shared_ptr &&sp);      //移动构造
  ~shared_ptr();

  T* operator ->() const;
  T& operator *() const;
  operator bool() const;

  shared_ptr &operator =(const shared_ptr &sp);  
  shared_ptr &operator =(shared_ptr &&sp); 

  T* get() const;
  void reset(T *ptr);
  void swap(shared_ptr &sp);
  int count();

private:
  atomic<int> *use_count;
  T *ptr;
};

template <typename T, typename Deleter>
shared_ptr<T, Deleter>::shared_ptr()
{}

template <typename T, typename Deleter>
shared_ptr<T, Deleter>::shared_ptr(T *_ptr)
 : ptr(_ptr), use_count(new atomic<int>(1))
{}

template <typename T, typename Deleter>
shared_ptr<T, Deleter>::shared_ptr(const shared_ptr &sp)
 : ptr(sp.ptr), use_count(sp.use_count)
{
  ++*use_count;
}

template <typename T, typename Deleter>
shared_ptr<T, Deleter>::shared_ptr(shared_ptr &&sp)
{
  std::swap(ptr, sp.ptr);
  std::swap(use_count, sp.use_count);
}

template <typename T, typename Deleter>
shared_ptr<T, Deleter>::~shared_ptr()
{
  if(ptr) {
  	--*use_count;
  	if(*use_count <= 0) {
  	  Deleter()(ptr);
  	  delete use_count;
  	  cout << "shared_ptr dctor" << endl;
  	}
  }
}

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

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

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

/* 异常安全赋值 */
template <typename T, typename Deleter>
shared_ptr<T, Deleter> &shared_ptr<T, Deleter>::operator= (const shared_ptr<T, Deleter> &sp)
{
#if 1
  //copy and swap
  shared_ptr<T, Deleter> tmp(sp);
  swap(tmp);
  return *this;
#else
  //自我赋值
  if(sp.ptr == ptr) return *this;

  ptr = sp.ptr;
  use_count = sp.use_count;
  ++*use_count;
  return *this;
#endif
}

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

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

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

  ptr = _ptr;
  use_count = new atomic<int>(1);
}

template <typename T, typename Deleter>
void shared_ptr<T, Deleter>::swap(shared_ptr<T, Deleter> &sp)
{
  std::swap(ptr, sp.ptr);
  std::swap(use_count, sp.use_count); 
}

template <typename T, typename Deleter>
int shared_ptr<T, Deleter>::count()
{
  return *use_count;
}

}; //namespace smart_pointer


int main(int argc, char *argv[])
{
  {
    smart_pointer::shared_ptr<int> p(new int(12));
    smart_pointer::shared_ptr<int> p1(p);
    *p1 = 2;
    cout << *p << endl;
    cout << p.count() << endl;

    //异常安全测试
    p = p;
    cout << *p << endl;
    cout << p.count() << endl;
  }

  {
  	smart_pointer::shared_ptr<int> p(new int(12));
  	p.reset(new int(13));
  	cout << *p << endl;

  	//右值赋值测试
  	p = smart_pointer::shared_ptr<int>(new int(14));
  	cout << *p << endl;

  	//移动构造测试
  	smart_pointer::shared_ptr<int> p1(smart_pointer::shared_ptr<int>(new int(15)));
  	cout << *p1 << endl;
  }
  
  return 0;
}

有关更多 C++ 技术分享，请关注 「码尘」