【C++】模拟实现STL中的list

STL中的list是带头结点的双向循环链表，之前我们写过不带头结点的双向循环链表，在此基础上，增加了头结点和迭代器。

结点的结构

template <typename T>
struct Node
{
	Node(const T& data = T())
	: _data(data)
	, _next(NULL)
	, _pre(NULL)
	{}
	T _data;
	struct Node* _next;
	struct Node* _pre;
};

迭代器中的Begin应该指向头结点的下一个结点位置，而End应当指向头结点，如下图所示：

template<typename T,typename Ref,typename Ptr>//T,T&,T*
struct ListIterator
{
public:
	typedef Node<T> Node;
	typedef ListIterator<T, Ref, Ptr> Self;
	ListIterator()
		: _pCur(NULL)
	{}
	ListIterator(Node* pCur)
		: _pCur(pCur)
	{}
	ListIterator(const Self& s)
		: _pCur(s._pCur)
	{}
	Self& operator=(const Self& s)
	{
		if (*this != s)
			_pCur = s._pCur;
		return *this;
	}
	Ref operator*()
	{
		return _pCur->_data;
	}
	Ptr operator->()
	{
		return &(_pCur->_data);
	}
	Self& operator++()//前置++
	{
		_pCur = _pCur->_next;
		return *this;
	}
	Self operator++(int)//后置++
	{
		Self tmp(*this);
		_pCur = _pCur->_next;
		return tmp;
	}
	Self& operator--()//前置--
	{
		_pCur = _pCur->_pre;
		return *this;
	}
	Self operator--(int)//后置--
	{
		Self tmp(*this);
		_pCur = _pCur->_pre;
		return tmp;
	}
	bool operator==(const Self& s)
	{
		return _pCur == s._pCur;
	}
	bool operator!=(const Self& s)
	{
		return _pCur != s._pCur;
	}
	Node* _pCur;
};

在链表的头结点中，可以存放结点的个数，但是当结点个数非常多，超过了类型的最大取值范围时，就会出现溢出，不能正常表示结点个数了。

template <typename T>
class List
{
public:
	typedef Node<T> Node;
	typedef ListIterator<T, T&, T*> Iterator;
	List()//构造函数
		: _pHead(new Node)
	{
		_pHead->_next = _pHead;
		_pHead->_pre = _pHead;
	}
	List(const T* arr, size_t size)//构造函数
		: _pHead(new Node)
	{
		_pHead->_next = _pHead;
		_pHead->_pre = _pHead;
		for (size_t i = 0; i < size; i++)
			PushBack(arr[i]);
	}
	List(const List<T>& list)//拷贝构造
		: _pHead(new Node(list._pHead->_data))
	{
		_pHead->_next = _pHead;
		_pHead->_pre = _pHead;
		Node* cur = list._pHead->_next;
		while (cur != list._pHead)
		{
			PushBack(cur->_data);
			cur = cur->_next;
		}
	}
	bool operator==(const List<T>& list)
	{
		return _pHead == list._pHead;
	}
	bool operator!=(const List<T>& list)
	{
		return _pHead != list._pHead;
	}
	List<T>& operator=(const List<T>& list)//赋值运算符重载
	{
		if (*this != list)
		{
			_pHead = new Node(list._pHead->_data);
			_pHead->_next = _pHead;
			_pHead->_pre = _pHead;
			Node* cur = list._pHead->_next;
			while (cur != list._pHead)
			{
				PushBack(cur->_data);
				cur = cur->_next;
			}
		}
		return *this;
	}
	~List()//析构函数
	{
		Clear();
		delete _pHead;
		_pHead = NULL;
	}
	//Iterator///
	Iterator Begin()     //迭代器
	{
		return Iterator(_pHead->_next);
	}
	Iterator End()
	{
		return Iterator(_pHead);
	}
	Capacity
	bool Empty()//判断是否为空     
	{
		return _pHead->_next == _pHead;
	}
	size_t Size()const//结点个数
	{
		size_t size = 0;
		Node* pcur = _pHead->_next;
		while (pcur != _pHead)
		{
			size++;
			pcur = pcur->_next;
		}
		return size;
	}
	///Element access//
	T& Front()//首元素
	{
		return _pHead->_next->_data;
	}
	const T& Front()const
	{
		return _pHead->_next->_data;
	}
	T& Back()//尾元素
	{
		return _pHead->_pre->_data;
	}
	const T& Back()const
	{
		return _pHead->_pre->_data;
	}
    //Modifiers///
	void PushBack(const T& data)//尾插
	{
		/*Node* newNode = new Node(data);
		if (Empty())
		{
			_pHead->_next = newNode;
			newNode->_next = _pHead;
			newNode->_pre = _pHead;
			_pHead->_pre = newNode;
		}
		else
		{
			Node* pTail = _pHead->_pre;
			pTail->_next = newNode;
			newNode->_pre = pTail;
			newNode->_next = _pHead;
			_pHead->_pre = newNode;
		}*/

		Insert(End(), data);
	}
	void PopBack()//尾删
	{
		//if (Empty())
		//	return;
		//Node* pTail = _pHead->_pre;
		//pTail->_pre->_next = _pHead;
		//_pHead->_pre = pTail->_pre;
		//delete pTail;
		//pTail = NULL;

		Erase(--End());//先--，后使用，不能删头结点end(),所以需要--
	}
	void PushFront(const T& data)//头插
	{
		//Node* newNode = new Node(data);
		//newNode->_next = _pHead->_next;//只有头结点时，_pHead->_next=_pHead;
		//newNode->_pre = _pHead;
		//_pHead->_next->_pre = newNode;
		//_pHead->_next = newNode;

		Insert(Begin(), data);
	}
	void PopFront()//头删
	{
		//if (Empty())
		//	return;
		//Node* pDel = _pHead->_next;
		//_pHead->_next = pDel->_next;
		//pDel->_next->_pre = _pHead;
		//delete pDel;
		//pDel = NULL;

		Erase(Begin());//头删
	}
	Iterator Insert(Iterator pos, const T& data)//任意位置插入
	{
		Node* newNode = new Node(data);
		Node* cur = pos._pCur->_pre;
		newNode->_next = pos._pCur;
		newNode->_pre = cur;
		cur->_next = newNode;
		pos._pCur->_pre = newNode;
		return Iterator(newNode);
	}
	Iterator Erase(Iterator pos)//任意位置删除
	{
		assert(pos._pCur != _pHead);//pos不能是头结点
		Node* cur = pos._pCur->_pre;
		cur->_next = pos._pCur->_next;
		pos._pCur->_next->_pre = cur;
		delete pos._pCur;
		pos._pCur = NULL;
		return Iterator(cur->_next);//返回pos的下一个节点
	}
	void Clear()//清空有效结点，即只剩下头结点
	{
		Iterator it = Begin();
		while (it != End())
			it = Erase(it);
		_pHead->_next = _pHead;
		_pHead->_pre = _pHead;
	}
private:
	Node* _pHead;
};

注意：在使用Erase(pos)删除指定位置结点时，pos不能是list.Begin()。

测试函数如下：

int main()
{
	int arr[3] = { 1, 2, 3 };
	List<int> list;
	List<int> list1(arr, sizeof(arr) / sizeof(arr[0]));
	List<int> list2(list1);
	List<int> list3;
	list3 = list1;
	list.PushBack(1);
	list.PushBack(2);
	list.PushBack(3);
	list.PopBack();
	list.PopBack();
	list.PopBack();
	list.PushFront(1);
	list.PushFront(2);
	list.PushFront(3);
	list.PopFront();
	list.PopFront();
	list.PopFront();
	List<int>::Iterator it = list.Begin();
	while (it != list.End())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	cout << list.Size() << endl;
	cout << list.Back() << endl;
	cout << list.Front() << endl;

	list.Insert(list.Begin(), 100);
	list.Insert(list.Begin(), 200);
	list.Insert(list.Begin(), 300);
	list.Insert(list.Begin(), 400);
	list.Erase(list.Begin());
	list.Erase(--list.End());//使用erase不能删除头结点，即end();
	list.Clear();
	List<int>::Iterator it = list.Begin();
	while (it != list.End())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	cout << list.Size() << endl;
	cout << list.Back() << endl;
	cout << list.Front() << endl;
	return 0;
}