STL中list的简单实现

STL中的list是由双链表来实现的，也就是说，在list上可以高效地执行插入删除操作，但不能很快地实现查找操作，简单实现代码如下：

//list的简单实现，双链表形式
template <typename Object>
class List
{
	//首先定义三个内部的嵌套类
private:
	struct Node; //List 中的节点，嵌套类
public:
	class const_iterator; //迭代器，嵌套类
	class iterator; //继承const_iterator, 嵌套类
	
	//默认构造函数
	List() : head(NULL), tail(NULL), theSize(0)
	{
		init();
	}

	//复制控制成员
	List(const List &rhs) : head(Null), tail(NULL), theSize(0)
	{
		init();
		for(const_iterator itr = rhs.begin(); itr != rhs.end(); ++itr)
			push_back(*itr);
	}
	List& operator(const List &rhs)
	{
		if (this == &rhs)
			return *this;
		clear();
		for(const_iterator itr = rhs.begin(); itr != rhs.end(); ++itr)
			push_back(*itr);
		return *this;
	}
	~List()
	{
		clear();
		delete head;
		delete tail;
	}

	//常用操作
	iterator begin()
	{
		return iterator(head->next);
	}

	const_iterator begin() const
	{
		return const_iterator(head->next);
	}

	iterator end()
	{
		return iterator(tail);
	}

	const_iterator end() const
	{
		return const_iterator(tail);
	}

	int size() const
	{
		return theSize;
	}

	bool empty() const
	{
		return size() == 0;
	}

	void clear()
	{
		while(!empty())
			pop_front();
	}

	Object& front()
	{
		return *begin();
	}

	const Object& front() const
	{
		return *begin();
	}

	Object& back() 
	{
		return *--end();
	}

	const Object& back() const
	{
		return *--end();
	}

	void push_back(const Object &x)
	{
		insert(end(), x);
	}

	void push_front(const Object &x)
	{
		insert(begin(), x);
	}

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

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

	//在itr之前插入，返回指向插入节点的迭代器
	iterator insert(iterator itr, const Object &x)
	{
		Node* p = itr.current;//p指向当前要插入的位置
		++theSize; //节点数目加1
		Node* newNode = new Node(x, p->prev, p); //建立一个要插入的节点
		p->prev->next = newNode;
		p->prev = newNode;
		return iterator(newNode);
	}

	//删除itr所指节点，返回被删除节点的下一个节点的迭代器
	iterator erase(iterator itr)
	{
		Node *p = itr.current;
		iterator retVal(p->next);
		p-prev-next = p->next;
		p->next->prev = p->prev;
		delete p;
		--theSize;
		return retVal;
	}

	//删除指定区间内的元素,一个迭代器，它指向被删除元素段后面的元素
	iterator erase(iterator start, iterator end)
	{
		for(iterator itr = start; itr != end)
			itr = erase(itr);
		return to;
	}
private:
	//默认构造函数和复制构造函数中使用的init()
	void init()
	{
		theSize = 0;
		head = new Node;;
		tail = new Node;
		head->next = tail;
		tail->prev = head;
	}

	//List的数据成员
	int theSize;
	Node *head;
	Node *tail;

};

//嵌套类Node的定义
template <typename object>
struct List<Object>::Node()
{
	Object data;
	Node *prev;
	Node *next;
	Node(const Object &d = Object(), Node *p = NULL; Node *p = NULL) : data(d), prev(p), next(n) { }
};

//嵌套类 const_iterator
template <typename Object>
class List<Object>const_iterator
{
	friend class List<Oject>;
public:
	const_iterator() : current(NULL)
	{ }
	const_iterator(Node *p) : current(p)
	{ }
	const Object& operator*() const
	{
		return retrieve();
	}

	const_iterator& operator++() //重载前自增操作符
	{
		if(current->next == NULL) //迭代器已经指向了tail节点
			throw out_of_range(increment past the end of List);
		current = current->next;
		return *this;
	}

	const_iterator operator++(int)
	{
		const_iterator old = *this;
		++(*this);
		return old;
	}

	bool operator==(const const_iterator& rhs) const 
	{ //一般情况下，重载关系操作符应该定义为非成员操作符
	  //此处为了方便
		return current = rhs.current;
	}

	bool operator!=(const const_iterator& rhs) const
	{
		return !(*this == rhs.current);
	}

protected:
	Node *current;

	Object& retrive() const
	{
		return current->data;
	}
};

//嵌套类iterator
template <typename object>
class List<Object> iterator : public class List<Object> const_iterator
{
	friend class List<Object>;
public:
	iterator() { }
	iterator(Node *p) : const_iterator(p)
	{ }

	Object& operator*()
	{
		return retrive();
	}

	const Object& operator*() const
	{
		return const_iterator::operator*();
	}

	iterator& operator++()
	{
		if(current->next == NULL) //迭代器已经指向了tail节点
			throw out_of_range(increment past the end of List);
		current = current->next;
		return *this;
	}

	iterator operator++(int)
	{
		iterator old = *this;
		++(*this);
		return old;
	}

	iterator(Node *p) : const_iterator(p)
	{ }

};

<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">注意：这只是个数据结构的简单实现，并没有考虑类似于迭代器指向末尾标记或者没有初始化的时候，还可以执行++和*操作这种错误。</span>