模拟实现容器List（迭代器）

#include <iostream>
using namespace std;

template<class T>
struct ListNode
{
	ListNode(const T& data = T())
	: _pPre(0)
	, _pNext(0)
	, _data(data)
	{}

	ListNode* _pPre;
	ListNode* _pNext;
	T _data;
};

//迭代器
template <class T,class Ref,class Pointer>
class ListIterator
{
	typedef ListIterator Self;
public:
	ListIterator()
		: _pCur(0)
	{}

	ListIterator(ListNode<T>* pCur)
		: _pCur(pCur)
	{}

	ListIterator(const Self& s)
		: _pCur(s._pCur)
	{}

	Ref operator*()
	{
		return _pCur->_data;
	}

	Ref operator->()
	{
		/*return &(operator*());*/
		return &(_pCur->_data); 
	}

	Self& operator++()//前置++
	{
		_pCur = _pCur->_pNext;
		return*this;
	}

	Self operator++(int)//后置++
	{
		Self temp(*this);
		_pCur = _pCur->_pNext;
		return temp;
	}

	Self& operator--()//前置--
	{
		_pCur = _pCur->_pPre;
		return*this;
	}

	Self operator--(int)//后置--
	{
		Self temp(*this);
		_pCur = _pCur->_pPre;
		return temp;
	}

	bool operator!=(const Self& s)
	{
		return _pCur != s._pCur;
	}

	bool operator==(const Self& s)
	{
		return _pCur == s._pCur;
	}

	ListNode<T>* _pCur;
};

template <class T>
class List
{
public:
	typedef ListIterator<T,T&,T*> Iterator;
	typedef ListNode<T>* Node;
public:
	List()
		: _pHead(new ListNode<T>)
	{
		_pHead->_pNext = _pHead;//头结点
		_pHead->_pPre = _pHead;
	}

	List(const T* array, size_t size)
		:_pHead(new ListNode<T>)
	{
		_pHead->_pNext = _pHead;//头结点
		_pHead->_pPre = _pHead;

		for (size_t i = 0; i < size; ++i)
		{
			PushBack(array[i]);
		}
	}
	List(const List& l)//拷贝构造
		:_pHead(new ListNode<T>)
	{
		_pHead->_pNext = _pHead;//头结点
		_pHead->_pPre = _pHead;
		Node first = l._pHead->_pNext;
	
		while (first != l._pHead->_pPre)
		{
			PushBack(first->_data);
			first = first->_pNext;
		}
	}
	List& operator=(const List& l)
	{
		if (this != &l)
		{
			_pHead = l._pHead;
			Iterator it = Begin();
			while (it != End())
			{
				Insert(it);
				it++;
			}
		}
	}
	~List()
	{
		Clear();
		delete _pHead;
		_pHead = NULL;
	}

	///
	Iterator Begin()
	{
		return Iterator(_pHead->_pNext);
	}

	Iterator End()
	{
		return Iterator(_pHead);
	}
	/Modify// 
	void PushBack(const T& data)
	{
		Node pTail = _pHead->_pPre;//尾指针
		Node pNewNode = new ListNode<T>(data);
		if (Empty())//空链表
		{
			_pHead->_pNext = pNewNode;
			pNewNode->_pNext = _pHead;
			_pHead->_pPre = pNewNode;
			pNewNode->_pPre = _pHead;
		}
		else//链表非空
		{
			Node pTail = _pHead->_pPre;//尾指针

			pTail->_pNext = pNewNode;
			pNewNode->_pPre = pTail;
			_pHead->_pPre = pNewNode;
			pNewNode->_pNext = _pHead;
		}

	}
	void PopBack()
	{
		if (Empty())
			return;
		else
		{
			Node pTail = _pHead->_pPre;//尾指针
			pTail = _pHead->_pPre->_pPre;
			delete pTail->_pNext;
			pTail->_pNext = _pHead;
			_pHead->_pPre = pTail;
 		}
	}
	void PushFront(const T& data)
	{
		Node pTail = _pHead->_pPre;//尾指针
		Node pNewNode = new ListNode<T>(data);
		pNewNode->_pNext = _pHead->_pNext;
		pNewNode->_pPre = _pHead;
		_pHead->_pNext->_pPre = pNewNode;
		_pHead->_pNext = pNewNode;
	}
	void PopFront()
	{
		if (Empty())
			return;
		else
		{
			Node tmp = _pHead->_pNext;
			_pHead->_pNext = tmp->_pNext;
			tmp->_pNext->_pPre = _pHead;
			delete tmp;
		}
	}
	Iterator Insert(Iterator pos, const T& data)
	{
		Node pNewNode = new ListNode<T>(data);
		pNewNode->_pNext = pos._pCur;
		pNewNode->_pPre = pos._pCur->_pPre;
		pos._pCur->_pPre->_pNext = pNewNode;
		pos._pCur->_pPre = pNewNode;
		return Iterator(pNewNode);
	}
	Iterator Erase(Iterator pos)
	{
		Node next = pos._pCur->_pNext;
		pos._pCur->_pPre->_pNext = pos._pCur->_pNext;
		pos._pCur->_pNext->_pPre = pos._pCur->_pPre;
		delete pos._pCur;

		return Iterator(next);
	}
	bool Empty()const
	{
		if (_pHead->_pNext == _pHead)
			return true;
		else
			return false;
	}
	size_t Size()const
	{
		int cout = 0;
		Node pnext = _pHead;
		Node pTail = _pHead->_pPre;
		while (pnext != pTail)
		{
			cout++;
			pnext = pnext->_pNext;
		}
	}
	T& Front()
	{
		return _pHead->_pNext->_data;
	}
	const T& Front()const
	{
		return _pHead->_pNext->_data;
	}
	T& Back()
	{
		return _pHead->_pPre->_data;
	}
	const T& Back()const
	{
		return _pHead->_pPre->_data;
	}
	void Clear()
	{
		Iterator it = Begin();

		while (it != End())
		{
			it = Erase(it);
		}
		_pHead->_pNext = _pHead;
		_pHead->_pPre = _pHead;
	}
private:
	ListNode<T>* _pHead;
};

测试函数

 

#include "List.h"

void test()
{
	int array[] = { 0, 1, 2, 3, 4 };
	List<int> l(array, sizeof(array) / sizeof(array[0]));

	l.PushBack(0);
	l.PushBack(1);
	l.PushBack(2);
	List<int>::Iterator it = l.Begin();
	while (it != l.End())
	{
		cout << *it << "->";
		++it;
	}
	cout << endl;

	l.PopFront();
	it = l.Begin();
	while (it != l.End())
	{
		cout << *it << "->";
		++it;
	}
	cout << endl;
	l.PopBack();
	it = l.Begin();
	while (it != l.End())
	{
		cout << *it << "->";
		++it;
	}
	cout << endl;
	l.PopFront();
	it = l.Begin();
	while (it != l.End())
	{
		cout << *it << "->";
		++it;
	}
	cout << endl;

	
}
void test2()
{
	List<int> l;
	l.PushBack(1);
	l.PushBack(1);
	l.PushBack(1);
	l.PushBack(1);
	l.PushBack(1);

	List<int> L1(l);

	List<int>::Iterator it = L1.Begin();
	while (it != L1.End())
	{
		cout << *it << "->";
		++it;
	}
	cout << endl;

	List<int> L2 = L1;
	it = L1.Begin();
	while (it != L1.End())
	{
		cout << *it << "->";
		++it;
	}
	cout << endl;

}

int main()
{
	test2();
	system("pause:");
	return 0;
}