list接口实现

//模拟实现list容器
namespace LIST
{
	
	template<class T>
	//list的节点类
	struct ListNode
	{	
		ListNode(const T& val = T())
			: _pPre(nullptr)
			, _pNext(nullptr)
			, _val(val)
		{}	
		ListNode* _pPre;
		ListNode* _pNext;
		T _val;
	};
	template<class T, class Ref, class Ptr>
	class ListIterator
	{
		typedef ListNode<T>* PNode;
		typedef ListIterator<T, Ref, Ptr> Self;
	public:
		ListIterator(PNode pNode = nullptr)
			: _pNode(pNode)
		{}
		ListIterator(const Self& l)
			: _pNode(l._pNode)
		{}
		T& operator*()
		{
			return _pNode->_val;
		}
		T& operator->()
		{
			return &(operator*());
		}
		Self& operator++()
		{
			_pNode = _pNode->_pNext;
			return *this;
		}
		Self& operator++(int)
		{
			Self tmp(*this);
			_pNode = _pNode->_pNext;
			return *this;
		}
		bool operator==(const Self& l)
		{
			return l._pNode == _pNode;
		}
		bool operator!=(const Self& l)
		{
			return l._pNode != _pNode;
		}
		




		PNode _pNode;

	};
	//反向迭代器
	template<class T, class Ref, class Ptr, class Iterator>
	class ListReverseIterator
	{
		typedef ListReverseIterator<T, Ref, Ptr, Iterator> Self;
	public:
		ListReverseIterator(const Iterator& it)
			: _it(it)
		{}
		ListReverseIterator(const Self& s)
			: _it(s._it)
		{}
		Ref operator*()
		{
			Iterator tmp = _it;
			return *(--tmp);
		}
		Ptr operator->()
		{
			return &operator*();
		}
		//反向迭代器的++就是正向迭代器的--；相反，方向迭代器的--就是正向迭代器的++
		Self& operator++()
		{
			--_it;
			return *this; 
		}
		Self& operator++(int)
		{
			Iterator tmp(_it);
			--_it;
			return *this;
		}
		Self& operator--()
		{
			++_it;
			return *this;
		}
		Self& operator--(int)
		{
			Iterator tmp(_it);
			++_it;
			return *this;
		}
		bool operator!=(const Self& s)
		{
			return _it != s._it;
		}
		bool operator==(const Self& s)
		{
			return _it == s._it;
		}
	private:
		Iterator _it;
	};
	template<class T>
	class list
	{
		typedef ListNode<T> Node;
		typedef Node* PNode;
	public:
		typedef ListIterator<T, T&, T*> Iterator;
		typedef ListIterator<T, const T&, const T*> ConstIterator;
		typedef ListReverseIterator<T, T&, T*, Iterator> ReverseIterator;
		typedef ListReverseIterator<T, const T&, const T*, ConstIterator> ConstReverseIterator;
	private:
		PNode _pHead;
	private:
		void CreateHead()
		{
			_pHead = new Node;
			_pHead->_pPre = _pHead;
			_pHead->_pNext = _pHead;
		}
	public:
		list()
		{
			CreateHead();
		} 
		list(int n, const T& value = T())
		{
			CreateHead();
			for(size_t i = 0; i < n; ++i)
			{
				PushBack(value);
			}
		}
		template<class Iterator>
		list(Iterator first, Iterator last)
		{
			CreateHead();
			while(first != last)
			{
				PushBack(*first);
				++first;
			}
		}
		//拷贝构造函数
		list(const list<T>& l)
		{
			CreateHead();
			list<T> tmp(l.cBegin(), l.cEnd());
			this->Swap(tmp);
		}
		list<T>& operator=(const list<T>& l)
		{
			if(this != &l)
			{
				list<T> tmp(l);
				this->Swap(tmp);
			}
			return *this;
		}
		~list()
		{
			Clear();
			delete _pHead;
			_pHead = nullptr;
		}
		Iterator Begin();
		{
			return Iterator(_pHead->_pNext);
		}
		Iterator End()
		{
			return Iterator(_pHead);
		}
		ConstIterator CBegin() const
		{
			return ConstIterator(_pHead->_pNext);
		}
		ConstIterator CEnd() const
		{
			return ConstIterator(_pHead);
		}
		ReverseIterator RBegin()
		{
			return ReverseIterator(_End());
		}
		ReverseIterator REnd()
		{
			return ReverseIterator(_Begin());
		}
		ConstReverseIterator CRBegin() const
		{
			return ConstReverseIterator(CEnd);
		}
		ConstReverseIterator CREnd() const
		{
			return ConstReverseIterator(CBegin());
		}
		size_t size() const
		{
			size_t count = 0;
			PNode pCur = _pHead->_Next;
			while(pCur->_Next != _pHead)
			{
				count++;
				pCur = pCur->_pNext;
			}
			return count;
		}
		bool Empty() const
		{
			return _pHead->_pNext == _pHead;
		}
		void resize(size_t newsize; const T& val = T())
		{
			size_t oldsize = size();
			if(oldsize <= newsize)
			{
				for(size_t i = oldsize; i < newsize; ++i)
					PushBack(val);
			}
			else
				for(size_t i = newsize; i < oldsize; ++i)
					PopBack();
		}
		//list access
		T& front()
		{
			return _pHead->_pNext->_val;
		}
		const T& front()const
		{
			return _pHead->_pNext->_val;
		}
		T& back()
		{
			return _pHead->_pPre->_val;
		}
		const T& back()const
		{
			return _pHead->_pPre->_val;
		}
		void PushBack(const T& val)
		{
			PNode pNewNode = new Node(val);
			pNewNode->_pNext = _pHead;
			pNewNode->_pPre = _pHead->_pPre;
			_pHead->_pPre = pNewNode;
			_pNewNode->_pPre ->_pNext = pNewNode;
		}
		void PopBack()
		{
			PNode pDel = _pHead->_pPre;
			if(pDel != pHead)
			{
				_pHead->_Pre = _pDel->_pPre;
				pDel->_pPre->_pNext = _pHead;
				delete pDel;
			}
		}
		void PushFront(const T& val)
		{
			PNode pNewNode = new Node(val);
			pNewNode->_pNext = _pHead->_pNext;
			pNewNode->_pPre = _pHead;
			_pHead->_pNext = pNewNode;
			pNewNode->_pNext->_pPre = pNewNode;
		}
		void PopFront()
		{
			PNode pDel = _pHead->_pNext;
			if(pDel != pHead)
			{
				_pHead->_pNext = pDel->_pNext;
				_pDel->_pNext->_pPre = _pHead;
				delete _pDel;
			}
		}
		//在pos位置前插入值为val的节点
		Iterator Insert(Iterator pos, const T& val)
		{
			PNode pNewNode = new Node(val);
			PNode pCur = pos._pNode;
			pNewNode->_pNext = pCur;
			pNewNode->_pPre = pCur->_pPre;
			pNewNode->_pPre->_pNext = pNewNode;
			pCur->_pPre = pNewNode;
			return Iterator(pNewNode);
		}
		Iterator Erase(Iterator pos)
		{
			PNode pDel = pos._pNode;
			pRet = pDel->_pNext;

			pDel->_pNext->_pPre = pDel->_pPre;
			pDel->_pPre->_pNext = pDel->_pNext;
			delete pDel;
			return Iterator(pRet);
		}
		void Clear()
		{
			PNode pCur = _pHead->_pNext;
			while(pCur != _pHead)
			{
				_pHead->_pNext = pCur->_pNext;
				delete pCur;
				pCur = _pHead->_pNext;
			}
			_pHead->_pNext = _pHead;
			_pHead->_pPre = _pHead;
		}
		void Swap(list<T>& l)
		{
			swap(_pHead, l._pHead);
		}

	};
}