STL list的模拟实现（反向迭代器）

list的模拟实现

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

首先 ，我们定义节点`

template <class T>
	struct list_node
	{
	T _data;
	list_node<T>* _next;
	list_node<T>* _prev;
	list_node(const T& x=T())
		:_data(x)
		, _next(nullptr)
		, _prev(nullptr)
	{
	}
	};

接下来，我们定义链表

template <class T>
class list
{
	typedef list_node<T> Node;
public:
//..................................其他
private:
Node* _head;
};

我们来看下面的代码。

void test()
{
list<int>li;
	list<int>::iterator it = li.begin();
	while (it != li.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	}

it是指向第一个节点的指针，解引用是第一个节点，++能到下一个位置吗？
不能，list不是一个连续的物理空间，但是我们可以用c++的特性，用类去封装迭代器，用运算符重载改变对象用运算符的行为。

迭代器

 template<class T,class Ref,class Ptr> //后两个参数是为了控制是普通迭代器还是const迭代器，如果是普通迭代器就传入T&，T*,如果是const迭代器就传入const T&,const T*。
   struct __list_iterator
   {
	   typedef list_node<T> Node;
	   typedef  __list_iterator<T,Ref,Ptr> iterator;
	   Node* _node;//一个节点的指针
	   __list_iterator(Node* node)
		   :_node(node)
	   { }
	   //不需要提供析构函数，因为迭代器只是遍历链表，如果手动释放链表，那就不正确了。
	   //拷贝赋值不需要写。
	   bool operator!=(const iterator& it)const  
	   {
		   return _node != it._node;
	   }
	   bool operator==(const iterator& it)const
	   {
		   return _node == it._node;
	   }
	   //*it  it.operator*()
	  Ref operator*()  //如果是const对象，就需要const迭代器，普通迭代器和const迭代器的区别是能否修改数据，所以为什么返回值是Ref,就是通过实例化确定是普通迭代器还是const迭代器，如果是普通迭代器，那么Ref就是T&,如果是const迭代器Ref就是const T&
	   {
		   return _node->_data;
	   }
	   
	   // it->a1  本质是it->->a1,it->实质上是it.operator->() ,是节点的指针，然后再->a1,就是节点的数据。语法为了可读性，编译器进行了特殊处理，省略了一个->
	   
	  Ptr operator->()//和Ref同理
	   {
		   return &(operator*());//等价于&(_node->data)  节点数据的指针
		}
	   iterator& operator++()//前置
	   {
		   _node = _node->_next;
		   return *this;
	   }
	   iterator& operator++(int)//后置  //返回++之前的值
	   {
		   iterator tmp(*this);
		   _node = _node->_next;
		   return tmp;
	   }
	   iterator& operator--()//前置
	   {
		   _node = _node->_prev;
		   return *this;
	   }
	   iterator& operator--(int)//后置
	   {
		   iterator tmp(*this);
		   _node = _node->_prev;
		   return tmp;
	   }

};

反向迭代器，一种的思维重写一份像普通迭代器一样，另一种思想是复用普通迭代器，我们可以用类去封装正向迭代器。

	template <class Interator, class Ref, class Ptr>//第一个参数是迭代器，第二第三个和上面同理。
	struct __reverse_iterator//复用，迭代器适配器，给一个容器的迭代器，就适配容器的反向迭代器
	{
		Interator _cur;
		typedef __reverse_iterator<Interator, Ref, Ptr> RIterator;
		__reverse_iterator(Interator it)
			:_cur(it)
		{

		}
		RIterator operator++()  //反向迭代器++就是普通迭代器--
		{
			--_cur;
			return *this;
		}
		RIterator operator--()//同理
		{
			++_cur;
			return *this;
		}
		Ref operator*()//解引用是返回它前一个位置的值，为什么要这样写，为了保持和普通迭代器对称。
		{
			auto tmp = _cur;
			--tmp;
			return *tmp;
		}
		Ptr operator->()
		{
			return &(operator*());//返回节点的指针
		}
		bool operator!=(const RIterator& it)
		{
			return _cur != it._cur;
		}

	};
}

（1）这里实现的反向迭代器是迭代器适配器，就是给一个容器的普通迭代器，我就能适配容器的反向迭代器，比如传入vector/list的普通迭代器，就能适配vector/list的反向迭代器，但并不是所有的容器都适配，迭代器支持++，- -的，可以适配，单链表不可以。

（2）功能的角度分类：
单向 迭代器 forward_list
双向迭代器 list map set
随机迭代器 deque vector
那这些分类有什么意义？

这里的名称暗示sort的容器迭代器用随机迭代器。

这里暗示你用双向迭代器/随机迭代器。

链表

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;
	const_iterator begin() const
	{
		return const_iterator(_head->_next);
	}
	const_iterator end() const
	{
		return const_iterator(_head);
	}
	iterator begin()
	{
		return iterator(_head->_next);
	}
	iterator end()
	{
		return iterator(_head);
	}
	const_iterator rbegin() const
	{
		return	const_reverse_iterator(end());
	}
	const_iterator rend() const
	{
		return const_reverse_iterator(begin());
	}
	reverse_iterator rbegin()
	{
		return	reverse_iterator(end());
	}
	reverse_iterator rend()
	{
		return reverse_iterator(begin());
	}
	list()
	{
		empty_init();
	}
	void empty_init()
	{     //创建并初始化哨兵位头结点
		_head = new Node;
		_head->_next = _head;
		_head->_prev = _head;
	}
	template<class InputIterator>//模板参数  可以用其他其他容器的迭代器区间构造
	list(InputIterator first, InputIterator last)//迭代器区间构造
	{
		empty_init();
		while (first != last)
		{
			push_back(*first);
			first++;
		}
	}
	//void swap(list & x) 在类里边可以这样写  类外不可以
	void swap(list<T>& x)
	{
		
		std::swap(_head, x._head);
	}
	void clear()
	{
		iterator it = begin();
		while (it != end())
		{
			it = erase(it);//这里迭代器会失效，所以要接收下一个迭代器。
		}
	}
	//list1(list2)
	//如果我们不写拷贝构造，编译器会给我们生成一个拷贝构造，对自定义类型，会实现值拷贝，list1和list2的_head指向同一个头结点，list2修改了会影响了list1,这是不对的，list1和list2应该互不影响。
	list(const list<T>& t)
	{        
		empty_init();
		list<T> tmp(t.begin(), t.end());
		swap(tmp);//局部对象出了作用域调用析构
	}
	list<T>& operator=(list<T> lt)//lt是一个局部对象
	{
		swap(lt);
		return *this;
	}
	~list()
	{
		clear();
		delete _head;
		_head = nullptr;
	}
	void push_back(const T& t)
	{
		Node* tail = _head->_prev;
		Node* newnode = new Node(t);
		tail->_next = newnode;
		newnode->_prev = tail;
		newnode->_next = _head;
		_head->_prev = newnode;

	}

	iterator insert(iterator pos, const T& x)//返回的是新插入元素的迭代器
	{
		Node* cur = pos._node;
		Node* prev = cur->_prev;
		Node* newnode = new Node(x);
		prev->_next = newnode;
		newnode->_prev = prev;
		newnode->_next = cur;
		cur->_prev = newnode;
		return iterator(newnode);
	}
	void push_front(const T& x)
	{
		insert(begin(), x);
	}
	void pop_back()
	{
		erase(--end());

	}
	void pop_front()
	{
		erase(begin());
}
	iterator erase(iterator pos)//pos失效，返回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);
	}
private:
	Node* _head;
};