STL中list的重写

#pragma once

#ifndef __________LIST______________
	#define __________LIST______________

	//*************************************************************
	template <typename _Ty>
	class list
	{
	private:
		struct _Node
		{
			_Ty tData;
			_Node* pNext;         //  双向链表
			_Node* pPrev;

			_Node():pNext(0),pPrev(0){}
		};
		_Node* m_pHead;
		_Node* m_pEnd;
		size_t uSize;          //  链表的长度 
	public:
		explicit list():m_pHead(0),m_pEnd(0),uSize(0)
		{
		
		}
		explicit list(size_t nCount,_Ty tData = 0):m_pHead(0),m_pEnd(0),uSize(0)
		{
			for(size_t i=0;i<nCount;i++)
				this->push_back(tData);
		}
		~list()
		{
			while(m_pHead)
				this->pop_front();
		}
	public:
		void push_back(_Ty tData)
		{
			//   创建一个一个节点
			_Node* temp = new _Node;
			temp->tData = tData;
			//   把这个节点放到链表的  尾
			if(!m_pHead)
			{
				m_pHead = temp;
				m_pEnd = temp;
			}
			else
			{
				m_pEnd->pNext = temp;
				temp->pPrev = m_pEnd;
				m_pEnd = temp;
			}
			++uSize;
		}
		bool Empty()
		{
			if(m_pHead == NULL)
				return true;
			return false;
		}
		void pop_front()   // 在 头删除
		{
			//  记住要删除的节点
			_Node* pDel = m_pHead;
			m_pHead = m_pHead->pNext;
			delete pDel;
			pDel = NULL;
			//  新的头的前一个指向空
			if(m_pHead != NULL)
				m_pHead->pPrev = NULL;

			--uSize;
		}
		void pop_back()     //  在尾删除
		{
			//  记住要删除的节点
			_Node* pDel = m_pEnd;
			m_pEnd = m_pEnd->pPrev;
			delete pDel;
			pDel = NULL;
			//  新的头的前一个指向空
			if(m_pEnd != NULL)
				m_pEnd->pNext = NULL;

			--uSize;
		}

	public:
		//------------------------list的迭代器---------------------------
		class _iterator_list
		{
		private:
			_Node* pNode;
		public:
			_iterator_list():pNode(0){}
			_iterator_list(_Node* ptr):pNode(ptr){}
		public:
			// operator ++
			_iterator_list operator++(int)
			{
				_iterator_list temp(pNode);
				pNode = pNode->pNext;
				return temp;
			}
			_iterator_list& operator++()
			{
				pNode = pNode->pNext;
				return *this;
			}
			// operator*
			_Ty& operator*()
			{
				return pNode->tData;
			}

			// operator!=
			bool operator!=(_iterator_list& ite)
			{
				return (pNode != ite.pNode)?true:false;
			}

			// operator==
			bool operator==(_iterator_list& ite)
			{
				return (pNode == ite.pNode)?true:false;
			}

			friend class list;

		};

		typedef _iterator_list iterator;

		//---------------------------------------------------------------
		iterator begin()
		{
			return iterator(m_pHead);
		}
		iterator end()
		{
			return iterator(NULL);
		}
		//  在指定的位置删除  ite
		iterator erase(iterator& ite)
		{
			//  看链表是不是空的
			if(this->Empty())
				return this->end();

			//  看 要删除的节点  是不是 头
			if(ite == this->begin())
			{
				this->pop_front();
				return this->begin();
			}
			//  看是不是尾
			if(ite.pNode == m_pEnd)
			{
				this->pop_back();
				return this->end();
			}

			//  中间删除
			ite.pNode->pPrev->pNext = ite.pNode->pNext;
			ite.pNode->pNext->pPrev = ite.pNode->pPrev;
			_Node* pTempNext = ite.pNode->pNext;
			delete ite.pNode;
			return iterator(pTempNext);
		}

	};
	//*************************************************************
#endif