c++实现 模板list

1.list简介

1.list是stl中的一种数据结构类型，stl为我们封装打包好。

2.list可以在常熟范围内任意位置进行插入何删除操作的序列容器，并且可以在前后双向迭代。

3.list的底层结构是双向链表结构，双向链表中的每个元素都存储在互不相关的独立节点中，在节点通过指针指向前一个和后一个元素

4.list和forward_list非常相似：最主要的的在于forward只能向前迭代，以让其简单高效。

5.优点：与其他容器相比（array，vector，deque）相比，list的在任意位置插入和移除元素的执行效率较高

6.缺点：不支持随机访问。

2.基本实现

Node节点

	template<class T>
	struct Node {
		Node(T& data = T())    //初始化
			:_next(nullptr)
			,_prve(nullptr)
			,_data(data)
		{}
		Node<T>* _next;     
		Node<T>* _prve;
		T _data;
	};

说明：

• Node主要负责存储数据，和数据之间链接
• 在Node的构造函数中使用了全缺省初始化列表

3.迭代器的封装

说明：在链表中，数据的结构在物理空间上不是连续的，我们想要通过++，--操作进行迭代器的移动不能对指针直接进行++/--，因此我们需要对迭代器进行封装，以达到，可以通过迭代器的++/--操作来访问链表的结点数据

	template<class T>
	struct list_iterator {
		typedef ListNode<T> Node;
		typedef list_iterator<T> Self;
	public://----------------------Init--------------------------------------
		list_iterator(Node* pcur)
			:pCur(pcur)
		{}
	public://------------------------解引用--------------------------------------
		T& operator*() {
			return pCur->_data;
		}
		T* operator->() {
			return &(pCur->_data);
		}
	public://----------------------迭代器的移动------------------------------------------
		Self& operator++() {
			pCur = pCur->_next;
			return *this;
		}
		Self operator++(int) {
			Self temp(*this);
			pCur = pCur->_next;
			return temp;
		}
		Self& operator--() {
			pCur = pCur->_prve;
			return *this;
		}
		Self operator--(int) {
			Self temp(*this);
			pCur = pCur->_prve;
			return temp;
		}
	public://--------------------------比较-----------------------------
		bool operator!=(const Self& it) {
			return pCur != it.pCur;
		}
		bool operator==(const Self& it) {
			return pCur == it.pCur;
		}
		

		Node*pCur;
	};

list

在list中我们实现一些基本操作

如：

• 头插，尾插，
• 头删，尾删
• 擦出所有data元素的数据

	template<class T>
	class list {
		typedef ListNode<T> Node;
		typedef list_iterator<T> iterator;
	public://-----------------------------初始化--------------------------
		list() {
			CreateHead();
		}
		list(const T& data) {
			CreateHead();
			InsertPos(pHead, data);
		}
		list(const list& L) {
			Node* p = L.pHead->_next;
			while (p != L.pHead) {
				PushBack(p->_data);
			}
		}
		template<class Iterator>
		list(Iterator frist, Iterator last) {
			CreateHead();
			while (frist != last) {
				PushBack(*frist);
				frist++;
			}
		}
		~list() {
			Clear();
			delete pHead;
			pHead = nullptr;
		}
	public://--------------可调用函数功能-----------------------
		size_t size() {
			size_t count;
			Node*p = pHead->_next;
			while (p != pHead) {
				count++;
				p = p->_next;
			}
		}
		//插入
		void InsertPos(Node* pos,const T& data) {
			Node* p = new Node(data);
			p->_next = pos;
			p->_prve = pos->_prve;
			p->_prve->_next = p;
			pos->_prve = p;
		}
		//尾插
		void PushBack(const T& data) {
			InsertPos(pHead, data);
		}
		//头插
		void PushHead(const T& data) {
			InsertPos(pHead->_next, data);
		}
		//头删
		void PopFront() {
			Node*p = pHead->_next;
			earse(pHead);
			pHead = p;
		}
		//尾删
		void PopBack() {
			earse(pHead->_prve);
		}
		//删除全部data元素
		void Remove(const T& data) {
			Node*p = pHead->_next;
			while (p != pHead) {
				if (p->_data == data) {
					Node*temp = p->_next;
					earse(p);
					p = temp;
					continue;
				}
				p = p->_next;
			}
		}
		//删除节点
		void earse(const Node* pos) {
			Node*p = pos->_next//防止删除头节点，保存头节点

			pos->_prve->_next = pos->_next;
			pos->_next->_prve = pos->_prve;
			delete pos;
			if (pos == pHead) {//删除头节点
				pHead = p;
			}
		}
		void Clear() {
			while (!empty()) {
				PopFront();
			}
		}
		bool empty() {
			return pHead->_next == pHead;
		}
	public://--------------迭代器操作----------------
		iterator begin() {
			return iterator(pHead->_next);
		}
		iterator end() {
			return iterator(pHead);
		}
	private://------------私有功能函数-------------
		void CreateHead() {
			Node* p = new Node(0);
			p->_next = p;
			p->_prve = p;
			pHead = p;
		}
	private:
		Node* pHead;
	};