迭代器的封装与反向迭代器

一、反向迭代器

在list模拟实现的过程中，第一次接触了迭代器的封装，将list的指针封装成了一个新的类型，并且以迭代器的基本功能对其进行了运算符重载

反向迭代器是对正向迭代器的封装，并且体现了泛型编程的思想，任意类型的双向迭代器都可以直接复用反向迭代器

本章将把两个迭代器的实现放在一起比对，更好的体会迭代器的封装

二、list正向迭代器的模拟实现

详解可以看list模拟实现那一章节，这里仅提供一份代码用于对照反向迭代器

	template<class T,class Ref,class Ptr>
	struct __list_iterator
	{
		typedef list_node<T> node;
		typedef __list_iterator<T, Ref, Ptr> self;
		node* _pnode;

		__list_iterator(node* p)
			:_pnode(p)
		{}

		self& operator++()
		{
			_pnode = _pnode->_next;
			return *this;
		}
		self& operator--()
		{
			_pnode = _pnode->_prev;
			return *this;
		}
		self operator++(int)
		{
			self tmp(_pnode);
			_pnode = _pnode->_next;
			return tmp;
		}
		self operator--(int)
		{
			self tmp(_pnode);
			_pnode = _pnode->_prev;
			return tmp;
		}
		Ref operator*()
		{
			return _pnode->_data;
		}
		Ptr operator->()
		{
			return &(_pnode->_data);
		}
		bool operator!=(const self& p)
		{
			return _pnode != p._pnode;
		}
		bool operator==(const self& p)
		{
			return _pnode == p._pnode;
		}
	};

三、反向迭代器的封装实现（双向迭代器）

反向迭代器的实现是对正向迭代器的封装

1.成员及其初始化

template<class Iterator,class Ref,class Ptr>
struct ReserveIterator
{
    typedef ReserveIterator self;//重命名方便使用
    Iterator _it;//成员变量
        
    ReserveIterator(Iterator it)
    :_it(it)
    {}
}

2.基本功能的重载

（1） ++ 和 --

在反向迭代器的概念中，反向迭代器++，就是正向迭代器--

self& operator++()
{
    _it--;
    return *this;
}
self& operator--()
{
    _it++;
    return *this;
}
//前置++和--
self operator++(int)
{
    self tmp(*this);
    _it--;
    return tmp;
}
self operator--(int)
{
    self tmp(*this);
    _it++;
    return tmp;
}

（2） != 和 ==

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

（3） -> 和 *

在实现operator*()之前，要先理解底层，在stl库内的实现，为了让begin()和rend(),所在的物理空间上对称，但在使用的角度上来看，并不对称，为了使其对称，且不影响使用，对*和->的实现作出了调整，解引用返回的是其前一个的位置

Ref operator*()
{
    Iterator tmp(_it);
    _it--;
    return *tmp; 
}
Ptr operator->()
{
    Iterator tmp(_it);
    _it--;
    return &(*_it);
}

3.定义部分

		typedef __list_iterator<T, T&, T*> iterator;
		typedef __list_iterator<T, const T&, const T*> con_iterator;
		typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
		typedef ReverseIterator<iterator,const T&,const T*> con_reverse_iterator;

		iterator begin()
		{
			return iterator(_head->_next);
		}
		iterator end()
		{
			return iterator(_head);
		}
		con_iterator begin()const
		{
			return con_iterator(_head->_next);
		}
		con_iterator end()const
		{
			return con_iterator(_head);
		}
		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}
		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}