【C++从0到1】第十二篇：STL--list

---

一、list的介绍及使用

1.1 list的介绍

1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。
3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)
   

1.2 list的使用

list中的接口比较多，此处类似，只需要掌握如何正确的使用，然后再去深入研究背后的原理，已达到可扩展的能力。以下为list中一些常见的重要接口

1.2.1 list的构造

构造函数（ (constructor)）	构造函数（ (constructor)）
list()	构造空的list
list (size_type n, const value_type& val = value_type())	构造的list中包含n个值为val的元素
list (const list& x)	拷贝构造函数
list (InputIterator first, InputIterator last)	用[first, last)区间中的元素构造list

1.2.2 list iterator的使用

此处，大家可暂时将迭代器理解成一个指针，该指针指向list中的某个节点

函数声明	接口说明
begin +end	返回第一个元素的迭代器+返回最后一个元素下一个位置的迭代器
rbegin+rend	返回第一个元素的reverse_iterator,即end位置，返回最后一个元素下一个位置的reverse_iterator,即begin位置

【注意】：

1. begin与end为正向迭代器，对迭代器执行++操作，迭代器向后移动
2. rbegin(end)与rend(begin)为反向迭代器，对迭代器执行++操作，迭代器向前移动

范围for打印

1.2.3 list capacity

函数声明	接口说明
empty	检测list是否为空，是返回true，否则返回false
size	返回list中有效节点的个数

1.2.4 list element access

函数声明	接口说明
front	返回list的第一个节点中值的引用
back	返回list的最后一个节点中值的引用

1.2.5 list modifiers

函数声明	接口说明
push_front	在list首元素前插入值为val的元素
pop_front	删除list中第一个元素
push_back	在list尾部插入值为val的元素
pop_back	删除list中最后一个元素
insert	在list position 位置中插入值为val的元素
erase	删除list position位置的元素
swap	交换两个list中的元素
clear	清空list中的有效元素

1.2.6 Operations:

1.2.7 list的迭代器失效

面说过，此处大家可将迭代器暂时理解成类似于指针，迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

二、list的模拟实现

List.h

#pragma once
#include <iostream>
#include <algorithm>
#include <assert.h>
#include "reverse_iterator.h"
using namespace std;

namespace ts
{
	template<class T>
	struct ListNode
	{
		ListNode<T>* _prev;
		ListNode<T>* _next;
		T _data;

		ListNode(const T& data = T())
			:_prev(nullptr)
			,_next(nullptr)
			,_data(data)
		{}
	};

	template<class T, class Ref, class Ptr>
	struct __list_iterator
	{
	public:
		typedef ListNode<T> Node;
		typedef __list_iterator<T, Ref, Ptr> self;
		Node* _node;

		__list_iterator(Node* x)
			:_node(x)
		{}

		//it2 = it1 浅拷贝
		//拷贝构造和赋值重载和不需要我们自己实现，默认生成的即可
		//析构也不需要，节点迭代器是借助节点去的指针取访问修改链表
		Ref operator*()
		{
			return _node->_data;
		}

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

		//++it
		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		//it++
		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;
		}

		bool operator!=(const self& x) const
		{
			return _node != x._node;
		}

		bool operator==(const self& x) const
		{
			return _node == x._node;
		}
	};
	
	//自己又实现一份__const__list_iterator
	//template<class T>
	//struct __const__list_iterator
	//{
	//public:
	//	typedef ListNode<T> Node;
	//	//typedef __list_iterator 
	//	Node* _node;

	//	__const__list_iterator(Node* x)
	//		:_node(x)
	//	{}

	//	//it2 = it1 浅拷贝
	//	//拷贝构造和赋值重载和不需要我们自己实现，默认生成的即可
	//	//析构也不需要，节点迭代器是借助节点去的指针取访问修改链表
	//	const T& operator*() 
	//	{
	//		return _node->_data;
	//	}

	//	//++it
	//	__const__list_iterator<T>& operator++()
	//	{
	//		_node = _node->_next;
	//		return *this;
	//	}

	//	//it++
	//	__const__list_iterator<T> operator++(int)
	//	{
	//		__const__list_iterator<T> tmp(*this);
	//		_node = _node->_next;
	//		return tmp;
	//	}

	//	__const__list_iterator<T>& operator--()
	//	{
	//		_node = _node->_prev;
	//		return *this;
	//	}

	//	__const__list_iterator<T> operator--(int)
	//	{
	//		__const__list_iterator<T> tmp(*this);
	//		_node = _node->_prev;
	//		return tmp;
	//	}

	//	bool operator!=(const __const__list_iterator<T>& x) const
	//	{
	//		return _node != x._node;
	//	}

	//	bool operator==(const __const__list_iterator<T>& x) const
	//	{
	//		return _node == x._node;
	//	}
	//};

	template<class T>
	class list
	{
		typedef ListNode<T> Node;

	public:
		typedef __list_iterator<T, T&, T*> iterator;
		typedef __list_iterator<T, const T&, const T*> const_iterator;

		typedef reverse_iterator<const_iterator, const T&, const T*> const_reverse_iterator;
		typedef reverse_iterator<iterator, T&, T*> reverse_iterator;

		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}

		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}

		iterator begin()
		{
			return iterator(_head->_next);
		}

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

		const_iterator begin() const
		{
			return const_iterator(_head->_next);
		}

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

		//list<int> l1
		list()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
		}

		//传统写法
		//list<int> l2(l1);
		//list(const list<T>& lt)
		//{
		//	//头结点
		//	_head = new Node;
		//	_head->_next = _head;
		//	_head->_prev = _head;

		//	for (auto e : lt)
		//	{
		//		push_back(e);
		//	}
		//}

		//传统写法
		//l2 = l1;
		/*list<T>& operator=(const list<T>& lt)
		{
			if (this != &lt)
			{
				clear();
				for (auto e : lt)
				{
					push_back(e);
				}
			}
			return *this;
		}*/

		//会与迭代器构造产生冲突
		//list<int>l2(4, 5), 因为size_t和int是两种不一样的类型，就会调用迭代器构造
		//我们可以使用一个重载版本解决
		list(size_t n, const T& val = T())
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;

			for (size_t i = 0; i < n; ++i)
			{
				push_back(val);
			}
		}

		list(int n, const T& val = T())
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;

			for (size_t i = 0; i < n; ++i)
			{
				push_back(val);
			}
		}
		//现代写法
		//迭代器构造list<int>l2(l1.begin(), l1.end());
		template<class InputIterator>
		list(InputIterator first, InputIterator last)
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;

			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		//现代写法
		//list<int>l2(l1);
		list(const list<T>& lt)
		{
			//不能直接给_head赋值为nullptr
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;

			list<T>tmp(lt.begin(), lt.end());
			swap(_head, tmp._head);
		}

		//现代写法
		//l1 = l2
		list<T>& operator=(list<T> lt)
		{
			swap(_head, lt._head);
			return *this;
		}

		~list()
		{
			clear();

			delete _head;
			_head = nullptr;
		}
		
		
		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				/*iterator del = it++;
				delete del._node;*/
				erase(it++);
			}

			_head->_next = _head;
			_head->_prev = _head;
		}

		void push_back(const T& x)
		{
			/*	Node* newNode = new Node(x);
				Node* tail = _head->_prev;
				tail->_next = newNode;
				newNode->_prev = tail;
				newNode->_next = _head;
				_head->_prev = newNode;*/

			insert(end(), x);
		}

		//insert以后迭代器不会失效
		iterator insert(iterator pos, const T& x)
		{
			Node* newNode = new Node(x);
			Node* cur = pos._node;
			Node* prev = cur->_prev;

			newNode->_next = cur;
			cur->_prev = newNode;
			newNode->_prev = prev;
			prev->_next = newNode;

			return iterator(newNode);
		}

		iterator erase(iterator pos)
		{
			assert(pos != end());

			Node* prev = pos._node->_prev;
			Node* next = pos._node->_next;
			delete pos._node;
			prev->_next = next;
			next->_prev = prev;

			return iterator(next);
		}

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

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

		//void f()
		//{
		//	//Node*原生指针和一个迭代器对象，他们占用的空间是一样大的
		//	//都是4个字节，并且存的值也是一样的。但是他们使用运算符的意义和结果是不一样的。
		//	Node* pnode = _head->_next;
		//	iterator it = _head->_next;

		//	*pnode;
		//	*it;
		//	
		//	++pnode;
		//	++it;
		//}

	private:
		Node* _head;	
	};

	struct Date
	{
		Date(int year = 1, int month = 1, int day = 1)
		{
			_year = year;
			_month = month;
			_day = day;
		}


		int _year;
		int _month;
		int _day;
	};
}

reverse_iterator.h（适配器）

#pragma once
namespace ts
{
	//适配器
	//Iterator是哪个容器，reverse_iterator<Iterator>就可以适配
	//出那个容器的反向迭代器。复用的体现。
	template<class Iterator, class Ref, class Ptr>
	class reverse_iterator
	{
		typedef reverse_iterator<Iterator, Ref, Ptr> self;
	public:
		reverse_iterator(Iterator it)
			:_it(it)
		{}

		//方向迭代器跟正向迭代器的区别就是++，--方向是相反的
		//所以反向迭代器就是对正向迭代器的封装
		Ref operator*()
		{
			Iterator prev = _it;
			return *--prev;
		}

		Ptr operator->()
		{
			return &operator*();
		}

		self& operator--()
		{
			++_it;
			return *this;
		}

		self& operator++()
		{
			--_it;
			return *this;
		}

		bool operator!=(const self& rit) const
		{
			return _it != rit._it;
		}

	private:
		Iterator _it;
	};
}