STL：list的模拟实现（迭代器失效探讨）

为什么重新设计list迭代器

对迭代器解引用，我们希望拿到的是指针所指向的值域，而直接解引用拿到的是指针所指向的节点
**对list指针++和- -

迭代器：

• 提供一种方法，使其能够按照顺序访问容器（聚合物）所含的各个元素，并且不用暴露容器内部的表述方式

本质

• 就是指针或者对指针的封装

实现

• 对原生态指针进行封装，即实现一个迭代器的类
• 在容器中给迭代器取别名：typedef 迭代器类型 iterator
• 在容器中增加begin和end的方法

使用：指针所具备的操作迭代器都需要有

• *和->
• 移动++，–
• 比较==，!=

用户只和list类进行交互，在list类中实例化迭代器的模板

先构造list的每一个节点

template<class T>
struct ListNode
{
	ListNode* prev;
	ListNode* next;
	T val;

	ListNode(const T& value = T())
		:prev(nullptr)
		, next(nullptr)
		, val(val)
	{}
};

正向迭代器设计

typedef P P
在反向迭代器类中没有P和R类型，但是在正向迭代器中有，需要去找

template<class T, class P, class R>
struct ListIterator
{
	typedef P P;
	typedef R R;
	typedef ListNode<T> Node;
	typedef ListIterator<T, P, R> iterator;

	Node* _pNode;//成员变量

	ListIterator(Node* pNode=nullptr)
		:_pNode(pNode)
	{}
	
	R operator*()
	{
		return _pNode->val;
	}
	
	P operator&()
	{
		return &(_pNode->val);
	}
	
	iterator& operator++()
	{
		_pNode = _pNode->next;
		return *this;
	}
	
	iterator operator++(int)
	{
		iterator tmp(*this);
		_pNode = _pNode->next;
		return tmp;
	}
	
	iterator& operator--()
	{
		_pNode = _pNode->prev;
		return *this;
	}
	
	iterator operator--(int)
	{
		iterator tmp(*this);
		_pNode = _pNode->prev;
		return tmp;
	}
	
	bool operator!=(const iterator& it)const
	{
		return _pNode != it->_pNode;
	}
	
	bool operator==(const iterator& it)const
	{
		return _pNode == it->_pNode;
	}
};

反向迭代器

反向迭代器是通过正向迭代器实例化出来的

加typename的原因

• P和R是在正向迭代器中的
• 静态成员变量也是按照类名::静态成员变量名访问的
• 如果不加typename修饰，编译器就不知道iterator后的是类型还是静态成员变量

template<class iterator>
struct rListIterator
{
	iterator _it;
	typename typedef iterator::R R;
	typename typedef iterator::P P;

	typedef rListIterator<iterator> riterator;
	
	R operator*()
	{
		iterator tmp = _it;
		tmp--;
		return *tmp;
	}

	P operator&()
	{
		return _it->_pNode->val;
	}

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

	riterator operator++(int)
	{
		_it--;
		return *this;
	}

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

	riterator operator--(int)
	{
		_it++;
		return *this;
	}

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

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

list类

template<class T>
	class list
	{
	private:
	    Node* _head;//成员变量
		void CreateHeadNode()
		{
			_head = new Node();
			_head->next = _head;
			_head->prev = _head;
		}
		
	public://确定类型，实例化模板类
		typedef ListNode<T> Node;
		typedef ListItertor<T, T*, T&> iterator;
		typedef ListItertor<T, const T*, const T&> const_iterator;

		typedef ListReverseIterator<iterator> reverse_iterator;
		typedef ListReverseIterator<const_iterator> const_reverse_iterator;

	public:
	//
	// 构造
		list()
		{
			CreateHeadNode();
		}

		list(int n, const T& val = T())
		{
			CreateHeadNode();
			for (int i = 0; i < n; ++i)
			{
				push_back(val);
			}
		}

		template<class Iterator>
		list(Iterator first, Iterator last)
		{
			CreateHeadNode();
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		list(const list<T>& L)
		{
			CreateHeadNode();
			for (auto e : L)
			{
				push_back(e);
			}
		}

		list<T> operator=(list<T> L)
		{
			this->swap(L);
			return *this;
		}

		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}

		/
		// 正向迭代器
		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());
		}

		///
		// 容量相关
		size_t size()const
		{
			size_t count = 0;
			Node* cur = _head->next;
			while (cur != _head)
			{
				++count;
				cur = cur->next;
			}
			return count;
		}

		bool empty()const
		{
			return _head == _head->next;
		}

		void resize(size_t newsize, const T& val = T())
		{
			size_t oldsize = size();
			if (newsize < oldsize)
			{
				// 将原链表中节点个数缩减到newsize个
				for (size_t i = newsize; i < oldsize; ++i)
				{
					pop_back();
				}
			}
			else
			{
				// 将原链表中有效节点的个数增加到newsize个
				for (size_t i = oldsize; i < newsize; ++i)
				{
					push_back(val);
				}
			}
		}

		
		// 元素访问
		T& front()
		{
			return _head->next->val;
		}

		const T& front()const
		{
			return _head->next->val;
		}

		T& back()
		{
			return _head->prev->val;
		}

		const T& back()const
		{
			return _head->prev->val;
		}

		///
		// 修改
		void push_front(const T& val)
		{
			insert(begin(), val);
		}

		void pop_front()
		{
			if (empty())
				return;

			erase(begin());
		}

		void push_back(const T& val)
		{
			insert(end(), val);
		}

		void pop_back()
		{
			if (empty())
				return;

			auto pos = end();
			--pos;
			erase(pos);
		}

		iterator insert(iterator Itpos, const T& val)
		{
			Node* pos = Itpos._pNode;
			Node* newNode = new Node(val);
			newNode->next = pos;
			newNode->prev = pos->prev;
			newNode->prev->next = newNode;
			pos->prev = newNode;
			return newNode;
		}

		iterator erase(iterator Itpos)
		{
			Node* pos = Itpos._pNode;
			if (pos == _head)
				return pos;

			// 将pos节点从链表中拆除下来
			pos->prev->next = pos->next;
			pos->next->prev = pos->prev;

			Node* retNode = pos->next;
			delete pos;
			return retNode;
		}

		void clear()
		{
			Node* cur = _head->next;
			// 采用头删法
			while (cur != _head)
			{
				_head->next = cur->next;
				delete cur;
				cur = _head->next;
			}

			_head->next = _head;
			_head->prev = _head;
		}

		void swap(list<T>& L)
		{
			std::swap(_head, L._head);
		}
	};