C++迭代器

迭代器的分类

迭代器有正向迭代器和反向迭代器两种，先来回顾一下正向迭代器，正向迭代器中begin()指向容器的第一个元素，end()指向容器的最后一个元素的下一个位置，而反向迭代器rbegin()指向最后一个元素，rend()指向第一个元素的前一个位置，接下来我们在list中通过正向迭代器改造出反向迭代器，首先我们要指明的是反向迭代器是通过正向迭代器构造而来。

正向迭代器

typedef list_node<T> Node;
public:
	//typedef __list_iterator iterator;
	typedef __list_iterator<T, T&, T*> iterator;
	typedef __list_iterator<T, const T&, const T*> const_iterator;

		//下面这样设计const迭代器是不行的,因为const迭代器期望指向的内容不能被修改,迭代器本身能被修改
		//typedef const list_node const_iterator;
iterator begin()
{
	//return _head->_next;//两种都可以,这种属于单参数支持隐式类型转换
	return iterator(_head->_next);
}

iterator end()
{
	//return _head->_prev;
	return iterator(_head);
}

const_iterator begin() const
{
	//return _head->_next;//两种都可以,这种属于单参数支持隐式类型转换
	return const_iterator(_head->_next);
}

const_iterator end() const
{
	//return _head->_prev;
	return const_iterator(_head);
}

反向迭代器

		//通过适配器,适配出反向迭代器
typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;

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());
}

Reverse_iterator类

template<class Iterator, class Ref, class Ptr>
struct ReverseIterator
{
typedef ReverseIterator<Iterator, Ref, Ptr> Self;
Iterator _it;//成员是正向迭代器--------正向迭代器构造出反向迭代器

ReverseIterator(Iterator it)
	:_it(it)
{

}

Ref operator*()
{
	Iterator tmp = _it;//赋给临时变量,因为不能去改变原it
	return *(--tmp);
}

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

Self& operator++()//调用正向迭代器的减减
{
	--_it;
	return *this;
}

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

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

rbegin()在底层实际上是调用的end()
rend()在底层实际上是调用的begin()

迭代器本质上是指针，那么又是怎么做到返回的rbegin这个迭代器指针解引用时，值为容器的最后一个值而不是最后一个值的下一个值呢？这是因为我们在底层对反向迭代器指针解引用时也做了处理

就是在当前为位置–之后再被解引用，同理rend()也是
因此在我们使用时呈现出的结果是这样

其实在底层实现时是这样

使得底层逻辑变得更加对称
此外重载的运算符++和–在底层对应的是正向迭代器的–和++