template<class T>
class smart_ptr
{
public:
	smart_ptr(T* ptr)
		:_ptr(ptr)
	{}
	~smart_ptr()
	{
		cout << "delete[]" << _ptr << endl;
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
	T& operator[](size_t i)
	{
		return _ptr[i];
	}
private:
	T* _ptr;
};

struct Date
{
	int _year;
	int _month;
	int _day;
	Date(int year = 1,int month = 1,int day = 1)
		:_year(year)
		,_month(month)
		,_day(day)
	{}
	~Date()
	{
		cout << "~Date()" << endl;
	}
};
int main()
{
	auto_ptr<Date> ap1(new Date);
	//ap1的管理權(quán)轉(zhuǎn)移給ap2
	auto_ptr<Date> ap2(ap1);
	//報(bào)錯(cuò)：對(duì)空指針進(jìn)行訪問
	ap1->_year++;
	unique_ptr<Date> up1(new Date);
	//報(bào)錯(cuò)：不支持拷貝
	unique_ptr<Date> up2(up1);
	//支持移動(dòng)，移動(dòng)后up1也為空，不能對(duì)其進(jìn)行訪問
	unique_ptr<Date> up2(move(up1));
	shared_ptr<Date> sp1(new Date);
	//支持拷貝也支持移動(dòng)
	shared_ptr<Date> sp2(sp1);
	shared_ptr<Date> sp3(move(sp1));
	return 0;
}

struct Date
{
	int _year;
	int _month;
	int _day;
	Date(int year = 1,int month = 1,int day = 1)
		:_year(year)
		,_month(month)
		,_day(day)
	{}
	~Date()
	{
		cout << "~Date()" << endl;
	}
};
template<class T>
class DeleteArray
{
public:
	void operator()(T* ptr)
	{
		delete[] ptr;
	}
};
template<class T>
void DeleteArrayFunc(T* ptr)
{
	deletr[] ptr;
};
int main()
{
	//這樣去構(gòu)造程序會(huì)報(bào)錯(cuò)
	//unique_ptr<Date> up(new Date[10]);
	//shared_ptr<Date> sp(new Date[10]);
	//解決方案1:因?yàn)閚ew[]經(jīng)常使用，因此unique_ptr和shared_ptr 
    //實(shí)現(xiàn)了?個(gè)特化版本，這個(gè)特化版本在析構(gòu)時(shí)用的delete[] 
	unique_ptr<Date[]> up(new Date[10]);
	shared_ptr<Date[]> sp(new Date[10]);
	//解決方案2:使用仿函數(shù)對(duì)象做刪除器
	//這里需要注意:unique_ptr和shared_ptr在支持刪除器的方式是有所不同的
	//unique_ptr在類模板參數(shù)支持的，shared_ptr是構(gòu)造函數(shù)參數(shù)支持的 
	unique_ptr<Date, DeleteArray<Date>> up1(new Date[10]);
	shared_ptr<Date> sp1(new Date[10], DeleteArray<Date>());
	// 函數(shù)指針做刪除器  
	unique_ptr<Date, void(*)(Date*)> up3(new Date[5], DeleteArrayFunc<Date>);
	shared_ptr<Date> sp3(new Date[5], DeleteArrayFunc<Date>);
	// lambda表達(dá)式做刪除器 
	auto del = [](Date* ptr) {delete[] ptr; };
	unique_ptr<Date, decltype(del)> up4(new Date[10], del);
	shared_ptr<Date> sp4(new Date[10], del);
	return 0;
}

int main()
{
	shared_ptr<Date> sp1(new Date(2025, 10, 9));
	shared_ptr<Date> sp2 = make_shared<Date>(2025, 10, 9);
	if (sp1)
		cout << "sp1 is not nullptr" << endl;
	return 0;
}

template<class T>
class auto_ptr
{
public:
	auto_ptr(T* ptr)
		:_ptr(ptr)
	{}
	auto_ptr(auto_ptr<T>& sp)
		:_ptr(sp._ptr)
	{
		sp._ptr = nullptr;
	}
	auto_ptr<T>& operator=(auto_ptr<T>& ap)
	{
		if (this != &ap)
		{
			if (_ptr)
				delete _ptr;
			_ptr = ap._ptr;
			ap._ptr = nullptr;
		}
		return *this;
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
};

template<class T>
	class unique_ptr
	{
	public:
		//	加explicit是防止普通指針隱式類型
		// 	轉(zhuǎn)化為智能指針對(duì)象
		explicit unique_ptr(T* ptr)
			:_ptr(ptr)
		{}
		~unique_ptr()
		{
			if (_ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
			}
		}
		T* operator->()
		{
			return _ptr;
		}
		T& operator*()
		{
			return *_ptr;
		}
		//不支持左值的拷貝構(gòu)造
		unique_ptr(const unique_ptr<T>& up) = delete;
		//不支持左值的賦值
		unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;
		//支持右值的拷貝構(gòu)造
		unique_ptr(unique_ptr<T>&& up)
			:_ptr(up._ptr)
		{
			up._ptr = nullptr;
		}
		//支持右值的賦值
		unique_ptr<T>& operator=(unique_ptr<T>&& up)
		{
			delete _ptr;
			_ptr = up._ptr;
			up._ptr = nullptr;
		}
	private:
		T* _ptr;
	};
}

template<class T>
	class shared_ptr
	{
	public:
		explicit shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}
		//拷貝
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			,_pcount(sp._pcount)
		{
			++(*_pcount);
		}
		~shared_ptr()
		{
			if (--(*_pcount) == 0)
			{
				delete _ptr;
				delete _pcount;
			}
		}
		//賦值
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				if (--(*_pcount) == 0)
				{
					delete _pcount;
					delete _ptr;
				}
				_ptr = sp._ptr;
				_pcount = sp._pcount;
				++(*_pcount);
			}
			return *this;
		}
		T* operator->()
		{
			return _ptr;
		}
		T& operator*()
		{
			return *_ptr;
		}
	private:
		T* _ptr;
		int* _pcount;
	};

template<class T>
class shared_ptr
{
public:
	explicit shared_ptr(T* ptr = nullptr)
		:_ptr(ptr)
		,_pcount(new int(1))
	{}
	template<class D>
	shared_ptr(T* ptr, D del)
		:_ptr(ptr)
		,_del(del)
		,_pcount(new int(1))
	{}
	void release()
	{
		if (--(*_pcount) == 0)
		{
			_del(_ptr);
			delete _pcount;
			_ptr = nullptr;
			_pcount = nullptr;
		}
	}
	shared_ptr(const shared_ptr<T>& sp)
		:_ptr(sp._ptr)
		,_pcount(sp._pcount)
		,_del(sp._del)
	{
		++(*_pcount);
	}
	~shared_ptr()
	{
		release();
	}
	shared_ptr<T>& operator=(const shared_ptr<T>& sp)
	{
		if (_ptr != sp._ptr)
		{
			release();
			_ptr = sp._ptr;
			_pcount = sp._pcount;
			++(*_pcount);
			_del = sp._del;
		}
		return *this;
	}
	int use_count() const
	{
		return *_pcount;
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
	int* _pcount;
	function<void(T*)> _del = [](T* ptr) {delete ptr; };
};