list反向迭代器的模拟实现

模拟list的反向迭代器

当学习了list正向迭代器后，list反向迭代器就是将它的++和–重载一下，你并且rbegin和rend也附上我们需要的值即可

//反向迭代器
template<class T, class Ref, class Ptr>
struct __list_reverse_iterator
{

	typedef __list_reverse_iterator<T, Ref, Ptr> self;

	typedef list_node<T> node;
	node* _node;

	__list_reverse_iterator(node* n)
		:_node(n)
	{}
	Ref operator*()
	{
		return _node->_val;
	}
	Ptr operator->()
	{
		return &_node->_val;
	}
	self& operator++()
	{
		_node = _node->_prev;
		return *this;
	}
	self operator++(int)
	{
		self tmp(_node);
		_node = _node->_prev;
		return tmp;
	}
	self& operator--()
	{
		_node = _node->_next;
		return *this;
	}
	self  operator--(int)
	{
		iterator tmp(_node);
		_node = _node->_next;
		return tmp;
	}
	bool operator!=(const self& s)
	{
		return _node != s._node;
	}
	bool operator==(const self& s)
	{
		return _node == s._node;
	}
};

在list类中的用法

typedef  __list_reverse_iterator<T, T&, T*> reverse_iterator;
reverse_iterator rbegin()
{
	return reverse_iterator(_head->_prev);
}
reverse_iterator rend()
{
	return reverse_iterator(_head);
}

这样能够完成我们反向迭代器需要的效果。
但是我们要写两份迭代器的代码，代码太过于冗余。
这样实属是不好的代码。

修改成所有容器都可以用的反向迭代器

反向迭代器和正向迭代器，只是++和–的效果不一样，其他的功能也都一样，
我们在学习了栈和队列，可以用相同的思路，用一个适配器。
所以将反向迭代器封装成一个类，用正向迭代器适配它。
这样所有的容器都可以用。

template<class Iterator,class Ref,class Ptr>
struct  ReverseIterator
{
	typedef ReverseIterator<Iterator,Ref,Ptr> Self;
	Iterator _cur;

	ReverseIterator(Iterator it)
		:_cur(it)
	{}

	Ref operator*()
	{
		Iterator tmp = _cur;
		--tmp;
		return *tmp;
	}
	Self& operator++()
	{
		--_cur;
		return *this;
	}
	Self& operator--()
	{
		++_cur;
		return *this;
	}
	bool operator!=(const Self& s)
	{
		return _cur != s._cur;
	}
};

在list中怎么用，正向迭代器在这里有介绍

typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
reverse_iterator rbegin()
{
	return reverse_iterator(end());
}
reverse_iterator rend()
{
	return reverse_iterator(begin());
}

总结

在第一种的反向迭代器只能使用于list，但是如果我们想要用vector，只能用第二种方法。将正向的头设置成反向的尾，正向的尾设置成反向的头。解引用就是--然后再解引用。

所以所有容器的反向迭代器都可以用第二种反向迭代器。