以模板模拟实现List容器

#pragma once


#include <iostream>
using namespace std;

template<class T>
struct ListNode
{
	ListNode(const T& x = T())
		: _prev(0)
		, _next(0)
		, _value(x)
	{}

	ListNode<T>* _prev;
	ListNode<T>* _next;
	T _value;
};

template<class T, class Ref, class Ptr>
struct __ListIterator__
{
	typedef __ListIterator__<T, T&, T*> Iterator;
	typedef __ListIterator__<const T, const T&, const T*> ConstItrator;
	typedef __ListIterator__<T, Ref, Ptr> Self;
	typedef T ValueType;
	typedef Ref Reference;
	typedef Ptr Pointer;
	typedef ListNode<T>* LinkType;
	typedef size_t SizeType;

	LinkType _node;

	__ListIterator__(LinkType x)
		:_node(x)
	{}
	__ListIterator__()
		:_node(0)
	{}
	__ListIterator__(const Iterator& x)
	{
		_node=x._node;
	}
	bool operator==(const Iterator& x)
	{
		return _node==x._node;
	}
	bool operator!=(const Iterator& x)
	{
		return _node!=x._node;
	}
	Reference operator*()
	{
		return (*_node)._value;
	}
	Pointer operator->()
	{
		return &((*_node)._value);
	}
	Self& operator++()
	{
		_node=_node->_next;
		return *this;
	}
	Self operator++(int)
	{
		Iterator tmp=*this;
		_node=_node->_next;
		return tmp;
	}
	Self& operator--()
	{
		_node=_node->_prev;
		return *this;
	}
	Self operator--(int)
	{
		Iterator tmp=*this;
		_node=_node->_prev;
		return tmp;
	}
};

template<class T>
class List
{
public:
	typedef ListNode<T> Node;
	typedef T ValueType;
	typedef ValueType* Pointer;
	typedef const ValueType* ConstPointer;
	typedef ValueType& Reference;
	typedef const ValueType& ConstReference;
	typedef Node* LinkType;
	typedef size_t SizeType;
	typedef __ListIterator__<T, T&, T*> Iterator;
	typedef __ListIterator__<const T, const T& ,const T*> ConstIterator;
	List()
	{
		_node=new Node;
		_node->_next=_node;
		_node->_prev=_node;
	}
	Iterator Begin()
	{
		Iterator it;
		it._node=_node->_next;
		return it;
	}
	ConstIterator Begin()const
	{
		Iterator it;
		it._node=_node->_next;
		return it;
	}
	Iterator End()
	{
		Iterator it;
		it._node=_node;
		return it;
	}
	ConstIterator End()const
	{
		Iterator it;
		it._node=_node;
		return it;
	}
	bool Empty()const
	{
		return _node->_next==_node;
	}
	SizeType Size()const
	{
		Iterator it=Begin();
		SizeType count=0;
		while(it!=End())
		{
			it++;
			count++;
		}
		return count;
	}
	Reference Front()
	{
		return *Begin();
	}
	ConstReference Front()const
	{
		return *Begin();
	}
	Reference Back()
	{
		return *(--End());
	}
	ConstReference Back()const
	{
		return *(--End());
	}
	Iterator Insert(Iterator pos, const T& x)
	{
		LinkType pnode=new Node(x);
		pnode->_next=pos._node;
		pnode->_prev=pos._node->_prev;
		pos._node->_prev->_next=pnode;
		pos._node->_prev=pnode;

		return pos;
	}
	void PushFront(const T& x)
	{
		Insert(Begin(),x);
	}
	void PushBack(const T& x)
	{
		Insert(End(),x);
	}
	Iterator Erase(Iterator pos)
	{
		pos._node->_prev->_next=pos._node->_next;
		pos._node->_next->_prev=pos._node->_prev;
		Iterator it=pos;
		it++;
		delete pos._node;

		return it;
	}
	void PopFront()
	{
		if(Empty())
			return ;
		Erase(Begin());
	}
	void PopBack()
	{
		if(Empty())
			return ;
		Erase(--End());
	}
	void Clear()
	{
		Iterator it=Begin();
		while(it!=End())
		{
			Iterator tmp=it;
			it++;
			delete tmp._node;
		}
		it._node->_next=it._node;
		it._node->_prev=it._node;
	}
	List(const List<T>& l)
	{
		_node=new Node;
		_node->_next=_node;
		_node->_prev=_node;
		Iterator it=l.Begin();

		while(it!=l.End())
		{
			PushBack(it._node->_value);
			it++;
		}
	}
	List& operator=(const List& l)
	{
		if(this!=&l)
		{
			Clear();
			Iterator it=l.Begin();
			
			while(it!=l.End())
			{
				PushBack(it._node->_value);
				it++;
			}
		}
	}
	~List()
	{
		Iterator it=Begin();
		while(it!=End())
		{
			Iterator tmp=it;
			it++;
			delete tmp._node;
		}
		delete it._node;
	}
protected:
	LinkType _node;
};