C++进阶---STL中list的仿写

仅仅针对于内置类型，对于类类型而言仍然存在一定的问题待处理

/*
仿写list
*/

#include <iostream>
#include <string.h>
#include <cassert>
using namespace std;

template<typename _Ty>
class List
{

	/*
	结点类型
	*/
protected:
	struct _Node;
	typedef _Node* _Nodeptr;

	struct _Node
	{
		int _Value;
		_Nodeptr _Next;
		_Nodeptr _Prev;
	};



	/*
	结点指针的封装类
	*/
	struct _Acc
	{
		typedef _Nodeptr& _Nodepref;
		typedef _Ty& _Vref;

		static _Nodepref _Next(_Nodeptr _P)
		{
			return (_Nodepref)(*_P)._Next;
		}

		static _Nodepref _Prev(_Nodeptr _P)
		{
			return (_Nodepref)(*_P)._Prev;
		}

		static _Vref _Value(_Nodeptr _P)
		{
			return (_Vref)(*_P)._Value;
		}
	};


	/*
	迭代器的封装
	*/
	typedef _Ty& reference;
	typedef _Ty* pointer;
	class iterator;
	typedef iterator _It;

	class iterator
	{
	protected:
		_Nodeptr _Ptr;
	public:
		 iterator() {}
		 iterator(_Nodeptr _P) :_Ptr(_P) {}

		reference operator*()const
		{
			return _Acc::_Value(_Ptr);
		}

		pointer operator->()const
		{
			return &**this;
		}

		iterator& operator++()
		{
			_Ptr = _Acc::_Next(_Ptr);
			return *this;
		}

		iterator operator++(int)
		{
			iterator _Tmp = *this;
			++* this;
			return _Tmp;
		}

		iterator& operator--()
		{
			_Ptr = _Acc::_Prev(_Ptr);
			return *this;
		}

		iterator operator--(int)
		{
			iterator _Tmp = *this;
			--* this;
			return _Tmp;
		}

		bool operator==(iterator& _X) const
		{
			return _Ptr == _X._Ptr;
		}

		bool operator!=(iterator& _X)const
		{
			return !(*this == _X);
		}

	    
		_Nodeptr _Mynode()const
		{
			return _Ptr;
		}


	};



	/*
迭代器方法
*/
public:
	iterator begin()
	{
		return (iterator)_Acc::_Next(_Head);
	}

	iterator end()
	{
		return (iterator)_Head;
	}





	/*
	List的构造函数
	*/
public:

	explicit List() :_Head(_Buynode()), _Size(0) {}
	explicit List(size_t _N, const _Ty&_V = _Ty()) :_Head(_Buynode()), _Size(0)
	{
		insert(begin(),_N, _V);
	}

	List(_Ty* _F, _Ty* _L) :_Head(_Buynode()), _Size(0)
	{
		insert(begin(), _F, _L);
	}

	List(List& _X) :_Head(_Buynode()), _Size(0)
	{
		insert(begin(), _X.begin(), _X.end());
	}

	

	/*
    析构函数
	*/

	~List()
	{
		clear();
		_Freenode(_Head);
		_Head = nullptr;
		_Size = 0;
	}

	void _Freenode(_Nodeptr _S)
	{
		free(_S);
	}


	/*
	获取list状态的方法
	*/

	size_t size()const
	{
		return _Size;
	}

	bool empty()const
	{
		return size() == 0;
	}

	reference front()
	{
		return *begin();
	}

	reference back()
	{
		return *(--end());
	}

	void push_back(_Ty& _X)
	{
		insert(end(), _X);
	}

	void push_front(_Ty& _X)
	{
		insert(begin(), _X);
	}

	void pop_front()
	{
		erase(begin());
	}

	void pop_back()
	{
		erase(--end());
	}

	void clear()
	{
		erase(begin(), end());
	}

	void remove(const _Ty& _V)
	{
		iterator _L = end();
		for (iterator _F = begin(); _F != _L;++_F)
		{
			if (*_F == _V)
			{
				erase(_F);
			}
		}
	}


	/*
	插入List
	*/
	void insert(iterator _P, size_t _M, const _Ty& _X)
	{
		for (; _M > 0; --_M)
		{
			insert(_P, _X);
		}
	}

	iterator insert(iterator _P, const _Ty& _X = _Ty())
	{
		_Nodeptr _S = _P._Mynode();
		_Acc::_Prev(_S) = _Buynode(_S, _Acc::_Prev(_S));
		_S = _Acc::_Prev(_S);
		
		_Acc::_Next(_Acc::_Prev(_S)) = _S;
		_Acc::_Value(_S) = _X;

		++_Size;
		return iterator{ _S };
	}

	void insert(iterator _P, _It _F, _It _L)
	{
		for (; _F != _L; ++_F)
		{
			insert(_P, *_F);
		}
	}

	void insert(iterator _P, _Ty* _F, _Ty* _L)
	{
		for (; _F != _L; ++_F)
		{
			insert(_P, *_F);
		}
	}



	/*
	删除结点
	*/

	iterator erase(iterator _P)
	{
		_Nodeptr _S = _P++._Mynode();
	    _Acc::_Next(_Acc::_Prev(_S)) = _Acc::_Next(_S);
		_Acc::_Prev(_Acc::_Next(_S)) = _Acc::_Prev(_S);
	  
		_Freenode(_S);
		--_Size;
		return _P;
	}


	iterator erase(iterator _F, iterator _L)
	{
		while (_F != _L)
		{
			erase(_F++);
		}
		return _F;
	}


	/*
	assign赋值
	*/

	void assign(_It _F, _It _L)
	{
		clear();
		insert(begin(), _F, _L);
	}

	void assign(size_t _N, const _Ty& _X = _Ty())
	{
		clear();
		insert(begin(), _N, _X);
	}




	/*
	辅助方法
	*/
protected:
	_Nodeptr _Buynode(_Nodeptr _Narg = nullptr, _Nodeptr _Parg = nullptr)
	{
		_Nodeptr _newnode = (_Nodeptr)malloc(sizeof(_Node));
		assert(_newnode != nullptr);
		_Acc::_Next(_newnode) = _Narg != nullptr ? _Narg : _newnode;
		_Acc::_Prev(_newnode) = _Parg != nullptr ? _Parg : _newnode;
		return _newnode;
	}

	

   /*
   List属性成员
   */
protected:
	_Nodeptr _Head;
	size_t _Size;

};