智能指针 模拟

智能指针 模拟

#include <functional>
namespace sjy
{
    
	template <typename T>
	class auto_ptr
	{
    
	public:
		auto_ptr(T* ptr = nullptr)
			:_ptr(ptr)
		{
    }
		~auto_ptr()
		{
    
			delete _ptr;
		}
		auto_ptr(const auto_ptr<T>& other)
			:_ptr(other._ptr)
		{
    
			other._ptr = nullptr;
		}
		auto_ptr<T>& operator=(auto_ptr<T>& other)
		{
    
			if (&other != this)
			{
    
				delete _ptr;
				_ptr = other._ptr;
				other._ptr = nullptr;
			}
			return *this;
		}
		T& operator*()
		{
    
			return *_ptr;
		}
		T* operator->()
		{
    
			return _ptr;
		}
	private:
		T* _ptr;
	};

	template <typename T>
	class unique_ptr
	{
    
	public:
		unique_ptr(T* ptr = nullptr)
			:_ptr(ptr)
		{
    }
		~unique_ptr()
		{
    
			delete _ptr;
		}
		unique_ptr(const unique_ptr<T>& other) = delete;
		unique_ptr<T>& operator=(unique_ptr<T>& other) = delete;
		T& operator*()
		{
    
			return *_ptr;
		}
		T* operator->()
		{
    
			return _ptr;
		}
	private:
		T* _ptr;
	};

	template <typename T>
	struct DeleteArray
	{
    
		void operator()(T* ptr)
		{
    
			delete[] ptr;
		}
	};

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

	template <typename T>
	class weak_ptr
	{
    
	public:
		weak_ptr()
			:_ptr(nullptr)
		{
    }

		weak_ptr(const shared_ptr<T>& other)
			:_ptr(other._ptr)
		{
    }

		~weak_ptr() = delete;

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

		T* operator->()
		{
    
			return _ptr;
		}
	private:
		T* _ptr;
	};
}

#include <iostream>
#include <string>
#include <memory>
using namespace std;

class Person
{
    
public:
	Person(string name)
	{
    
		_name = name;
	}

	static void beg()
	{
    
		cout << "Please, Don't Hurt Me! " << endl;
	}
private:
	string _name;
};

struct Destruction
{
    
	void operator()(Person* ptr)
	{
    
		ptr->beg();
		delete[] ptr;
	}
};

int main()
{
    
	// unique_ptr<Person[]> myPtr(new Person[3]{ Person("Jake"),Person("Mike"),Person("Jeff") });
	unique_ptr<Person[], Destruction> myPtr(new Person[3]{
     Person("Jake"),Person("Mike"),Person("Jeff") });

	return 0;
}