手写一下智能指针

手写一下智能指针吧

#pragma once

template<typename T>
struct defaultDeleter{
    void operator() (const T* ptr){//常量指针，不可修改指向对象的内容
        delete ptr;
        ptr = nullptr;
    }
};

template<typename T, typename Deleter = defaultDeleter<T>>
class UniquePtr {
//默认是private，需要主动声明为public
//否则无法调用构造函数
public:
    typedef Unique<T> _T
    //constexpr 关键字告诉编译器，可以大胆的优化，并且参数和返回值为字面值
    //（C11中）代码有且只有一行return
    constexpr UniquePtr():_data(nullptr){}

    //必须要指向堆对象，不能是引用
    explicit UniquePtr(const T* sor) : _data(sor){}

    //T& operator =(const T* sor) : _data(sor){}

    T& operator*(){
        return *_data;
    }

    T* operator -> (){
        return _data;
    }

    ~UniquePtr(){
        delete _data;
        _data = nullptr;
    }

    void reset(T* ptr = nullptr){
        if(ptr){
            Deleter()(_data);
            _data = ptr;
            ptr = nullptr;
        }
        else{//没有输入
            Deleter(_data);
        }
    }

    
//定义为private 并且不实现，避免别人实现或者调用（子类继承）
private:
    UniquePtr(const _T& sor);
    _T& operator= (const _T& sor);

private:
	T *_data;
};

template<typename T>
class SharedPtr {
public:
	constexpr SharedPtr():_count(nullptr), _data(nullptr){}
	explicit SharedPtr(const SharedPtr<T> &sor) {
		if (this != &sor) {
			_count = sor._count;
			_data = sor._data;
			++*_count;
		}
	}

	explicit SharedPtr(const T& sor) {
		_count = new size_t(1);
		_data = new T(sor);
	}

	~SharedPtr() {
		--*_count;
		if (*_count == 0) {
			delete _data;
		}
		_count = nullptr;
		_data = nullptr;
	}

//这个是无符号的用来计数的类型
//typedef unsigned int     size_t; 这是C标准库里面的定义
//typedef int              ptrdiff_t;
//typedef int              intptr_t;
	size_t GetUsed() {	return *_count;}

	T& operator * () {	return *_data;}

	T* operator -> () {	return _data;}

	SharedPtr<T>& operator = (const SharedPtr<T>& sor) {
		if (this == &sor) {
			return *this;
		}
		//如果原来已经有对象则减少引用
		if (this->_data != nullptr && 0 == --*this->_count) {
			delete _data;
			delete _count;
		}
		++*sor._count;
		_count = sor._count;
		_data = sor._data;
		return *this;
	}

private:
	size_t *_count;
	T *_data;
};

class WeakPtr {
//默认是private，需要主动声明为public
//否则无法调用构造函数
public:



};


class AutoPtr {
};