手撕unique_ptr 和 shareed_ptr

unique_ptr

template<class T>
class Unique_ptr
{
private:
    T* ptr=NULL;
public:
	//1、删除默认的拷贝构造函数
    Unique_ptr(Unique_ptr& u) = delete;
    //2、删除默认的复制构造
    Unique_ptr& operator=(Unique_ptr& u) = delete;     
    //有参构造函数
    Unique_ptr(T* p)
    {
        ptr = p;
        cout << "构造" << endl;
    }
    //默认构造函数
    Unique_ptr()
    {
    }
    //析构函数
    ~Unique_ptr()
    {
        if (ptr)
        {
            delete ptr;
            ptr = NULL;
            cout << "析构" << endl;
        }
    }
    //重写带右值的拷贝构造
    Unique_ptr(Unique_ptr&& p)
    {
        ptr = p.ptr;
        p.ptr = NULL;
    }
    //重写传参是右值的复制构造
    Unique_ptr& operator=(Unique_ptr&& p)
    {
	    //防止自赋值
        if(this!=&p){
            ptr = p.ptr;
            p.ptr = NULL;
        }
        return *this;
    }
    
    T* operator->()
    {
        return ptr;
    }
    T& operator*()
    {
        if (ptr)
        {
            return *ptr;
        }
        T a = -1;
        return a;     }
};

shared_ptr

template <typename T>
class myshared_ptr
{
public:
	//有参构造
	myshared_ptr(T* value) //:ptr(value), count(new int(1))
	{
		ptr = value;
		//引用计数+1
		count++;
	}
	//拷贝构造
	myshared_ptr(const myshared_ptr& m) {
		ptr = m.ptr; 
		count = m.count; 
		//引用计数+1
		count++;
	}
	//赋值构造
	myshared_ptr& operator=(const myshared_ptr& m) {
		if (this != &m) {
			ptr = m.ptr; 
			count = m.count;
			//引用计数+1
			count++;
		}
		return *this;
	}
	T& operator->() {
		return this->ptr;
	} 
	~myshared_ptr() {
		count--;
		if (this->count== 0) {
			delete ptr;
			cout << "释放内存空间" << endl;
		}
	}
public:
	T* ptr;
	static int count;
};
template <typename T>
int myshared_ptr<T>::count = 0;