STL——List

一、简介

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

二、模拟实现

namespace test
{
	//节点类
	template<class T>
	struct List_Node
	{
		List_Node<T>* _prev;
		List_Node<T>* _next;
		T _val;

		List_Node(const T&val = T())
			:_prev(nullptr)
			,_next(nullptr)
			,_val(val)
		{}
	};

	//反向迭代器
	template<class Iterator, class Ref, class Ptr>
	struct reverse_iterator
	{
		Iterator _it;//用正向迭代器构造反向迭代器
		typedef reverse_iterator<Iterator, Ref, Ptr> Self;

		reverse_iterator(Iterator it)
			:_it(it)
		{}
		//*(解引用运算符重载)
		Ref operator*()
		{
			Iterator tmp = _it;
			return *(--tmp);
		}

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

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

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

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

	//迭代器类
	template<class T, class Ref, class Ptr>
	struct List_iterator
	{
		typedef List_Node<T> Node;
		typedef List_iterator<T,Ref,Ptr> Self;
		Node* _node;
		List_iterator(Node* node )
			:_node(node)
		{}

		Ref operator*()
		{
			return _node->_val;
		}
		Ptr operator->()
		{
			//return &(operator*());
			return &_node->_val;
		}
		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;
		}
		bool operator!=(const Self& it)
		{
			return _node != it._node;
		}
		bool operator==(const Self& it)
		{
			return _node == it._node;
		}
	};
	




	//list 类
	template<class T>
	class list
	{
		typedef List_Node<T> Node;
		
	public:
		//迭代器重命名 简化代码
		typedef List_iterator<T,T&,T*> iterator;
		typedef List_iterator<T, const T&,const T*> const_iterator;

		typedef Reverse_iterator<iterator, T&, T*> reverse_iterator;
		typedef Reverse_iterator<const_iterator, const T&, const T*> const_reverse_iterator;
		//正向和反向迭代器
		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);
		}

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

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

		const_reverse_iterator rbegin() const
		{
			
			return const_reverse_iterator(end());
		}

		const_reverse_iterator rend() const
		{
			return const_reverse_iterator(begin());
		}

		
		//判空
		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
		}
		//构造函数
		list()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
		}
		//根据迭代器区间初始化List
		template<class InputIterator>
		list(InputIterator first, InputIterator last)
		{
			empty_init();
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}
		
		void swap(list<T>& it)
		{
			std::swap(_head, it._head);
		}
		//拷贝构造
		list(const list<T>& it)
		{
			empty_init();
			list<T> tmp(it.begin(),it.end());
			swap(tmp);
		}
		//赋值运算符重载
		list<T>& operator=(list<T> it)
		{
			swap(it);
			return *this;
		}
		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}
		//尾插
		void push_back(const T& x)
		{
			/*Node* newnode = new Node(x);
			Node* tail = _head->_prev;

			newnode->_next = _head;
			newnode->_prev = tail;
			tail->_next = newnode;
			_head->_prev = newnode;*/
			//复用，在end位置insert
			insert(end(),x);
		}
		void push_front(const T& x)
		{
			//复用，在begin位置insert
			insert(begin(),x);
		}
		//尾删
		void pop_back()
		{
			erase(--end());
		}

		void pop_front()
		{
			erase(begin());
		}
		//双向链表的插入(传入插入位置的迭代器和要插入的值)
		void insert(iterator pos, const T& x)
		{
			Node* newnode = new Node(x);

			Node* cur = pos._node;
			Node* prev = cur->_prev;

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

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

		}
		//删除
		iterator erase(iterator pos)
		{
			assert(pos!= end());
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;

			prev->_next = next;
			next->_prev = prev;
			delete cur;

			return iterator(next);
		}


		void clear()
		{
			auto it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}
	private:
		Node* _head;
	};
}