list类的模拟实现

list类的模拟实现主要是迭代器的实现，list类的迭代器是一个类，所有的操作都是以迭代器为基础实现的

//节点类
template<typename T>
class ListNode
{
public:
	ListNode(const T&value = T()) :Prev(nullptr), Next(nullptr), Val(value)
	{}
	~ListNode()
	{}
public:
	ListNode<T>*Prev;
	ListNode<T>*Next;
	T Val;
};
//迭代器类
template<typename T>
class ListIterator
{
public:
	ListIterator() :Ptr(nullptr)
	{}
	ListIterator(ListNode<T>*p) :Ptr(p)
	{}
	~ListIterator()
	{}
public:
	ListNode<T>*GetNode()
	{
		return Ptr;
	}
public:
	ListIterator& operator++()
	{
		Ptr = Ptr->Next;
		return *this;
	}
	ListIterator operator++(int)
	{
		ListIterator tmp(*this);
		++*this;
		return tmp;
	}
	ListIterator& operator--()
	{
		Ptr = Ptr->Prev;
		return *this;
	}
	ListIterator operator--(int)
	{
		ListIterator tmp(*this);
		--*this;
		return tmp;
	}
public:
	bool operator==(const ListIterator&p)
	{
		return Ptr == p.Ptr;
	}
	bool operator!=(const ListIterator&p)
	{
		return !(*this == p);
	}
	T& operator*()
	{
		return Ptr->Val;
	}
	T* operator->()
	{
		return&(Ptr->Val);
	}
private:
	ListNode<T>*Ptr;
};
//list类
template<typename T>
class List
{
public:
	typedef ListIterator<T> iterator;
	typedef const ListIterator<T> const_iterator;
public:
	//构造和析构函数
	List() :Head(_BuyNode()), Size(0)
	{}
	List(size_t n, const T&value = T()) :Head(_BuyNode()), Size(0)
	{
		while (n--)
			push_back(value);
	}
	List(T*p1, T*p2) :Head(_BuyNode()), Size(0)
	{
		while (p1 != p2)
		{
			push_back(*p1);
			p1++;
		}
	}
	~List()
	{
		clear();
		delete Head;
		Head = nullptr;
		Size = 0;
	}
public:
	size_t size()const
	{
		return Size;
	}
	bool empty()const
	{
		return Size == 0;
	}
public:
	//增删
	void push_back(const T&value)
	{
		insert(end(), value);
	}
	void push_front(const T&value)
	{
		insert(begin(),value);
	}
	void clear()
	{
		erase(begin(),end());
	}
	void insert(iterator pos, const T&value)
	{
		ListNode<T>*s = _BuyNode(value);
		ListNode<T>*p = pos.GetNode();
		s->Next = p;
		s->Prev = p->Prev;
		s->Prev->Next = s;
		s->Next->Prev = s;
		Size++;
	}
	void insert(iterator pos, size_t n, const T&value)
	{
		while (n--)
			insert(pos,value);
	}
	void insert(iterator pos, iterator p1, iterator p2)
	{
		while (p1 != p2)
		{
			insert(pos, *p1);
			p1++;
		}
	}
	iterator erase(iterator pos)
	{
		ListNode<T>*p = pos.GetNode();
		iterator s = ++pos;
		p->Prev->Next = p->Next;
		p->Next->Prev = p->Prev;
		delete p;
		Size--;
		return s;
	}
	void erase(iterator pos1, iterator pos2)
	{
		while (pos1 != pos2)
		{
			pos1 = erase(pos1);
		}
	}
	ListNode<T>* _BuyNode(const T&value = T())
	{
		ListNode<T>*p = new ListNode<T>;
		p->Next = p->Prev = p;
		p->Val = value;
		return p;
	}
public:
	//迭代器
	iterator begin()
	{
		return iterator(Head->Next);
	}
	const_iterator begin()const
	{
		return const_iterator(Head->Next);
	}
	iterator end()
	{
		return iterator(Head);
	}
	const_iterator end()const
	{
		return const_iterator(Head);
	}
private:
	ListNode<T>* Head;
	size_t Size;
};

int main()
{

	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	List<int>t(10,2);
	List<int>t1(arr, arr + 9);
	t.insert(t.begin(),t1.begin(),t1.end());
	List<int>::iterator it = t.begin();
	while (it != t.end())
	{
		cout << *it << "-->";
		it++;
	}
	cout <<"over"<< endl;
	t.clear();
	return 0;
}