模拟实现双向带头循环链表list

#include<iostream>
using namespace std;

//list实现：双向带头循环链表
template<class T>
struct ListNode
{
	T _data;
	ListNode<T>* _next;
	ListNode<T>* _prev;

	ListNode(const T& val = T())
		:_data(val)
		,_next(nullptr)
		,_prev(nullptr)
	{}
};

迭代器类型
//template<class T>
//struct ListIterator
//{
//	typedef ListNode<T> Node;
//	//封装节点
//	Node* _node;
//	ListIterator(Node* node)
//		:_node(node)
//	{}
//
//	//*iterator
//	T& operator*()
//	{
//		return _node->_data;
//	}
//
//	//++iterator
//	ListIterator<T>& operator++()
//	{
//		_node = _node->_next;
//		return *this;
//	}
//
//	bool operator!=(const ListIterator<T>& it)
//	{
//		return _node != it._node;
//	}
//
//	//iterator++
//	ListIterator<T> operator++(int)
//	{
//		ListIterator<T> tmp(_node);
//		//ListIterator<T> tmp(*this);
//		//ListIterator<T> tmp = *this;
//		_node = _node->_next;
//		return tmp;
//	}
//
//	//使用场景：T为自定义类型，且包含多个成员
//	//通过->访问每一个成员
//	T* operator->()
//	{
//		return &_node->_data;
//	}
//
//	bool operator==(const ListIterator<T>& it)
//	{
//		return _node == it._node;
//	}
//
//	ListIterator<T>& operator--()
//	{
//		_node = _node->_prev;
//		return *this;
//	}
//};

const迭代器 
//template<class T>
//struct ConstListIterator
//{
//	typedef ListNode<T> Node;
//	//封装节点
//	Node* _node;
//	ConstListIterator(Node* node)
//		:_node(node)
//	{}
//
//	//++iterator
//	ConstListIterator<T>& operator++()
//	{
//		_node = _node->_next;
//		return *this;
//	}
//
//	bool operator!=(const ConstListIterator<T>& it)
//	{
//		return _node != it._node;
//	}
//
//	//iterator++
//	ConstListIterator<T> operator++(int)
//	{
//		ConstListIterator<T> tmp(_node);
//		//ListIterator<T> tmp(*this);
//		//ListIterator<T> tmp = *this;
//		_node = _node->_next;
//		return tmp;
//	}
//
//	//*iterator
//	const T& operator*()
//	{
//		return _node->_data;
//	}
//
//	//使用场景：T为自定义类型，且包含多个成员
//	//通过->访问每一个成员
//	const T* operator->()
//	{
//		return &_node->_data;
//	}
//
//	bool operator==(const ConstListIterator<T>& it)
//	{
//		return _node == it._node;
//	}
//
//	ConstListIterator<T>& operator--()
//	{
//		_node = _node->_prev;
//		return *this;
//	}
//};

//库中迭代器的实现
template<class T, class Ref, class Ptr>
struct ListIterator
{
	typedef ListNode<T> Node;
	typedef ListIterator<T, Ref, Ptr> self;
	//封装节点
	Node* _node;
	ListIterator(Node* node)
		:_node(node)
	{}

	//*iterator
	Ref operator*()
	{
		return _node->_data;
	}

	//++iterator
	self& operator++()
	{
		_node = _node->_next;
		return *this;
	}

	bool operator!=(const self& it)
	{
		return _node != it._node;
	}

	//iterator++
	self operator++(int)
	{
		self tmp(_node);
		//ListIterator<T> tmp(*this);
		//ListIterator<T> tmp = *this;
		_node = _node->_next;
		return tmp;
	}

	//使用场景：T为自定义类型，且包含多个成员
	//通过->访问每一个成员
	Ptr operator->()
	{
		return &_node->_data;
	}

	bool operator==(const self& it)
	{
		return _node == it._node;
	}

	self& operator--()
	{
		_node = _node->_prev;
		return *this;
	}
};


template<class T>
class List
{
public:
	typedef ListNode<T> Node;
	typedef Node* pNode;

	//iterator和const_iterator类型不同
	typedef ListIterator<T, T&, T*> iterator;
	/*typedef ConstListIterator<T> const_iterator;*/
	typedef ListIterator<T, const T&, const T*> const_iterator;

	iterator begin()
	{
		//创建一个迭代器对象：_node成员指向header->_next
		iterator it(_header->_next);
		return it;
		//return iterator(_header->_next);
	}

	iterator end()
	{
		iterator it(_header);
		return it;
		//return iterator(_header);
	}

	List()
		:_header(new Node())
	{
		//循环结构
		_header->_next = _header->_prev = _header;
	}

	List(size_t n, const T& val = T())
		:_header(new Node())
	{
		_header->_next = _header->_prev = _header;
		for (size_t i = 0; i < n; i++)
		{
			pushBack(val);
		}
	}

	template<class inputIterator>
	List(inputIterator first, inputIterator last)
		:_header(new Node())
	{
		_header->_next = _header->_prev = _header;
		while (first != last)
		{
			pushBack(*first);
			first++;
		}
	}

	void pushBack(const T& val)
	{
		/*Node* prev = _header->_prev;
		Node* newNode = new Node(val);

		prev->_next = newNode;
		newNode->_prev = prev;

		newNode->_next = _header;
		_header->_prev = newNode;*/
		insert(end(), val);
	}

	void pushFront(const T& val)
	{
		insert(begin(), val);
	}

	//迭代器指向的节点释放，迭代器失效
	//更新迭代器，返回值iterator指向被删除元素的下一个位置
	iterator erase(iterator pos)
	{
		//判断是否为有效位置
		if (pos ！ = end())
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;
			delete cur;
			prev->_next = next;
			next->_prev = prev;
			return iterator(next);
		}
		return pos;
	}

	void popBack()
	{
		erase(--end());
	}

	void popFront()
	{
		erase(begin());
	}

	void insert(iterator pos, const T& val)
	{
		Node* newNode = new Node(val);
		Node* cur = pos._node;
		Node* prev = cur->_prev;

		prev->_next = newNode;
		newNode->_prev = prev;

		newNode->_next = cur;
		cur->_prev = newNode;
	}

	~List()
	{
		if (_header)
		{
			Node* node = _header->_next;
			while (node != _header)
			{
				Node* next = node->_next;
				delete node;
				node = next;
			}
			delete _header;
			_header = nullptr;
		}
	}

	//深拷贝
	List(const List<T>& lst)
		:_header(new Node())
	{
		//循环结构
		_header->_prev = _header->_next = _header;
		for (auto& e : lst)
		{
			pushBack(e);
		}
	}

	//深拷贝
	List<T>& operator=(const List<T>& lst)
	{
		swap(_header, lst._header);
		return *this;
	}

private:
	ListNode<T>* _header;
};