反向迭代器

反向迭代器

以list和vector为例, 来讲解反向迭代器

1. 一般想法的反向迭代器

首先来实现一个list的反向迭代器，一般容易想到的想法就是去重新写一个反向迭代器的类, 以链表的尾结点作为反向迭代器的头结点, 迭代器的++是往前走, 迭代器的–是往后走。当然可以实现list反向迭代器的功能

但是存在缺陷:

1. 代码过于冗杂繁琐

2. 对于list这种自定义类型对原生指针的封装的迭代器可以这样实现， 但是对于vector这种原生指针类型的迭代器是无法这样实现的

那我们能不能只写一种迭代器类, list和vector都能用的呢?

namespace yj	
{	
	//反向迭代器一般想法
	template<class T, class Ref, class Ptr>
	struct _list_reverse_iterator
	{
		typedef list_node<T> node;
		typedef _list_reverse_iterator<T, Ref, Ptr> self;

		node* _node;

		_list_reverse_iterator(node* n)    //结点析构交给链表
			:_node(n)
		{}

		//解引用
		Ref operator*()
		{
			return _node->_data;
		}


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

		self& operator++()
		{
			_node = _node->_prev;

			return *this;
		}

		self& operator--()
		{
			_node = _node->_next;

			return *this;
		}

		self operator++(int)
		{
			self tmp(*this);
			_node = _node->_prev;

			return tmp;
		}

		self operator--(int)
		{
			self tmp(*this);
			_node = _node->_next;

			return tmp;
		}

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


		bool operator==(const self& s)
		{
			return _node == s._node;
		}
	};
    
    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 __list_reverse_iterator<T, T&, T*> reverse_iterator;

        reverse_iterator rbegin()
		{
			return reverse_iterator(_head->_prev);
		}

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

2. 真正的反向迭代器

参考库中反向迭代器的实现，发现:

反向迭代器的++就是正向迭代器的–，反向迭代器的–就是正向迭代器的++，因此反向迭代器的实现可以借助正向迭代器，即：反向迭代器内部可以包含一个正向迭代器，对正向迭代器的接口进行包装即可。

这就实现了一个通用的迭代器，vector和list都可以使用，只需要在vector和list类中再封装和声明一下即可

namespace yj
{
	template<class Iterator, class Ref, class Ptr>
	struct ReverseIterator
	{
		typedef ReverseIterator<Iterator, Ref, Ptr> self;
		Iterator _cur;


		ReverseIterator(Iterator it)  //构造   
			:_cur(it)
		{}

		//解引用
		Ref operator*()               //返回 _cur的前一个位置
		{
			Iterator tmp = _cur;
			--tmp;
			return *tmp;
		}


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


		self& operator++()
		{
			--_cur;

			return *this;
		}


		self& operator--()
		{
			++_cur;

			return *this;
		}


		self operator++(int)
		{
			self tmp = *this;
			--_cur;
			return tmp;
		}


		self operator--(int)
		{
			self tmp=*this;
			++_cur;
			return tmp;
		}


		bool operator!=(const self& s)
		{
			return _cur != s._cur;
		}


		bool operator==(const self& s)
		{
			return _cur == s._cur;
		}
	};
}

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 ReverseIterator<iterator, T&, T*> reverse_iterator;
	typedef ReverseIterator<iterator, const T&, const T*> const_reverse_iterator;

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

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

vector类中的封装:

namespace yj
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
		typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
		typedef ReverseIterator<iterator, const T&, const T*> const_reverse_iterator;
		
		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}

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