list不支持随机访问，不是线性连续存储，不能重载operator[],需要自定义它的迭代器

list的插入操作不会产生迭代器失效，删除操作会是指向被删除元素位置的迭代器实效，其它不受影响，而在vector中会造成后续迭代器失效

#pragma once

#include<iostream>
using namespace std;
template<class T>
struct ListNode
{
	T _data;
	ListNode<T>* _prev;
	ListNode<T>* _next;
	ListNode()
	{}
	ListNode(const T& x)
		:_prev(NULL)
		, _next(NULL)
		, _data(x)
	{}
};

template<class T,class Ref,class Ptr>
struct ListIterator
{
	typedef ListIterator<T, Ref, Ptr> self;
	typedef T ValueType;
	typedef Ref refrence;
	typedef Ptr point;
	ListNode<T>* _node;
	ListIterator()
	{}
	ListIterator(ListNode<T>* node)
		:_node(node)
	{}

	refrence operator*()  //T&
	{
		return _node->_data;//某个节点的值
	}
	point operator->()
	{
		return _node;
	}
	bool operator==(const self& s)
	{
		return _node == s._node;
	}
	bool operator!=(const self& s)
	{
		return _node!=s._node;
	}

	self& operator++() //前置++
	{
		_node = _node->_next;
		return *this;
	}
	self operator++(int)
	{
		self tmp(*this);
		_node = _node->_next;
		return tmp;
	}
	self& operator--()
	{
		_node = _node->_prev;
		return *this;
	}
	self operator--(int)
	{
		self tmp(*this);
		_node = _node->_prev;
		return tmp;
	}
	
};

template<class T>
class _List
{
	typedef ListNode<T> Node;
public:
	typedef ListIterator<T, T&, T*> Iterator;
	_List()
		:_head(new Node())
	{
		_head->_next = _head;
		_head->_prev = _head;//双向循环链表
	}

	Iterator Begin()
	{
		return Iterator(_head->_next);
	}

	Iterator End()
	{
		return Iterator(_head);//返回最后一个位置的下一个位置
	}

	void PushBack(const T& x)
	{
		Insert(End(), x);
	}

	void PopBack()
	{
		Erase(--End());
	}

	void PushFront(const T& x)
	{
		Insert(Begin(), x);
	}

	void PopFront()
	{
		Erase(Begin());
	}

	void Insert(Iterator pos, const T& x)
	{//在该位置的前边插入
		Node* tmp = new Node(x);
		Node* cur = pos._node;
		Node* prev = cur->_prev;
		tmp->_next = cur;
		cur->_prev = tmp;
		tmp->_prev = prev;
		prev->_next = tmp;
	}
	Iterator& Erase(Iterator pos)
	{
		if (pos == End())
			return;
		Node* del = pos._node;
		Node* prev = del->_prev;
		Node* next = del->_next;
		prev->_next = next;
		next->_prev = prev;
		delete del;
		del = NULL;
		return Iterator(next);
	}

	size_t Size()
	{
		Iterator cur = Begin();
		size_t size = 0;
		while (cur!=End())
		{
			++size;
			++cur;
		}
		return size;
	}

private:
	Node* _head;
};

void Test()
{
	_List<int>  l;
	l.PushBack(1);
	l.PushBack(2);
	l.PushBack(3);
	l.PushBack(4);
	l.PushBack(5);
	_List<int>::Iterator iter = l.Begin();
	while (iter != l.End())
	{
		cout << *iter << " ";
		++iter;
	}
	cout << endl;

	_List<int>::Iterator iter1 = --l.End();
	while (iter1 != l.Begin())
	{
		cout << *iter1 << " ";
		iter1--;
	}
	cout << *iter1 <<endl;
	//cout<<"size="<<l.Size() << endl;

}