STL容器中list与迭代器iterator的模拟实现

list在容器中结构是有一个头结点_head，头结点指向第一个结点，尾结点指向头结点，它为双向循环链表，在其中它有自己的迭代器可以类似于智能指针，用于数据的访问和算法的配合。

代码实现：

#include <iostream>
#include <cstdlib>
#include <assert.h>
#include <list>
using namespace std;

template <class T>
struct _ListNode    //结点结构
{
	T _data;
	_ListNode* _prev;
	_ListNode* _next;

	_ListNode(const T& x)
		:_data(x)
		,_prev(NULL)
		,_next(NULL)
	{}
};

template <class T,class Ref,class Ptr>
struct _ListIterator    //迭代器的模拟实现
{
	typedef _ListNode<T> Node;
	typedef _ListIterator<T,Ref,Ptr> Self;
	Node* _node;

	_ListIterator(){}
	_ListIterator(Node *node)
		:_node(node)
	{}

	_ListIterator(const Self &s)
		:_node(s._node)
	{}

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

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

	Ptr operator->()
	{
		return &_node->_data;
	}


	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;
	typedef _ListIterator<T,const T&,const T*> ConstIterator;

	Node* BuyNode(const T &x)
	{
		return new Node(x);
	}

	List()
		:_head(BuyNode(T()))
	{
		_head->_next=_head;
		_head->_prev=_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());
	}

	bool Empty()const  //判空
	{
		return _head==_head->_next;
	}
	
	void Insert(Iterator pos, const T& x)  //指定位置插入
	{
		assert(pos._node);
		Node *tmp=BuyNode(x);
		Node *prev=pos._node->_prev;
		prev->_next=tmp;
		tmp->_prev=prev;
		tmp->_next=pos._node;
		pos._node->_prev=tmp;
	}

	template <typename InputIterator>
	void Insert(Iterator pos,InputIterator first,InputIterator last)  //指定位置插入一段区间
	{
		while(first!=last)
		{
			Insert(pos,*first);
			++first;
		}
	}
	
	Iterator Erase(Iterator pos)  //删除指定位置
	{
		assert(pos._node&&pos._node!=_head);
		Node *prev=pos._node->_prev;
		Node *next=pos._node->_next;
		prev->_next=next;
		next->_prev=prev;
		Iterator it=pos;
		++it;
		delete pos._node;
		return it;
	}
    
    Iterator Begin()  //返回链表首位
	{
		return _head->_next;
	}

	ConstIterator Begin()const
	{
		return _head->_next;
	}

	Iterator End()  //返回链表末位下一位位置
	{
		return _head;
	}

	ConstIterator End()const
	{
		return _head;
	}

protected:
	Node *_head;
};

void PrintList(List<int> l)    //利用迭代器打印链表
{
	List<int>::Iterator it1=l.Begin();
	while(it1!=l.End())
	{
		cout<<(*it1)<<" ";
		++it1;
	}
	cout<<endl;
}
void FunTest()
{
	cout<<"自定义List:"<<endl;
	List<int> l1;
	//尾插
	l1.PushBack(1);
	l1.PushBack(2);
	l1.PushBack(3);
	l1.PushBack(4);
	l1.PushBack(5);
	PrintList(l1);
	//头插
	l1.PushFront(0);
	//迭代器访问链表数据
	PrintList(l1);
	l1.PopFront();  //头删
	PrintList(l1);
	l1.PopBack();//尾删
	PrintList(l1);
	l1.Insert(l1.Begin(),6);  //指定位置插入
	PrintList(l1);
	List<int>::Iterator it1=l1.Begin();
	++it1;
	int arr[]={10,20,30,40};
	l1.Insert(it1,arr,arr+4);
	PrintList(l1);
}

void Test()
{
	cout<<"库中list："<<endl;
	list<int> l1;
	//尾插
	l1.push_back(1);
	l1.push_back(2);
	l1.push_back(3);
	l1.push_back(4);
	l1.push_back(5);
	//头插
	l1.push_front(0);
	//迭代器访问链表数据
	list<int>::iterator it1=l1.begin();
	while(it1!=l1.end())
	{
		cout<<(*it1)<<" ";
		++it1;
	}
	cout<<endl;
	l1.pop_front();  //头删
	it1=l1.begin();
	while(it1!=l1.end())
	{
		cout<<(*it1)<<" ";
		++it1;
	}
	cout<<endl;
	l1.pop_back();//尾删
	l1.insert(l1.begin(),6);  //指定位置插入
	it1=l1.begin();
	while(it1!=l1.end())
	{
		cout<<(*it1)<<" ";
		++it1;
	}
	cout<<endl;
}
int main()
{
	//Test();
	FunTest();
	system("pause");
	return 0;
}

运行结果如图：

以上实现中主要实现了指定位置的插入删除，在头插，删，尾插，尾删等则可以直接调用它们来实现自己的功能。