C++:反向迭代器-reverse_iterator
目录
1.关于反向迭代器
2.反向迭代器的成员函数
1.构造
2.base
3.operator*
4.operator++
5.operator--
6.operator->
7.operator[]
3.反向迭代器的模拟实现
小结
1.关于反向迭代器
在C++中，可以使用反向迭代器来逆序遍历容器中的元素。反向迭代器是通过rbegin()和rend()方法来获取的，它们分别指向容器的最后一个元素和第一个元素的前一个位置。
此类反转双向或随机访问迭代器循环访问范围的方向。
原始迭代器（基础迭代器）的副本保留在内部，用于反映在reverse_iterator上执行的操作：每当reverse_iterator递增时，其基本迭代器就会减少，反之亦然。可以随时通过调用成员 base 获取具有当前状态的基迭代器的副本。
但请注意，当迭代器被反转时，反转的版本不会指向范围内的同一元素，而是指向它前面的元素。
反向迭代器的操作和正向迭代器大致相同，但是要特别注意++操作符，它会使反向迭代器指向前一个元素。
2.反向迭代器的成员函数
reverse_iterator的成员函数实现了反向迭代器的基本功能
下面介绍一些常用的功能：
1.构造
（1） 默认构造函数
构造一个不指向任何对象的反向迭代器。内部基迭代器是值初始化的。
（2） 初始化构造函数
从某个原始迭代器构造一个反向迭代器。构造对象的行为复制了原始对象，只是它以相反的顺序迭代其尖元素。
（3） 复制/类型转换构造函数
从其他反向迭代器构造反向迭代器。构造的对象保持与rev_it相同的迭代感。
2.base
返回基迭代器的拷贝。
基迭代器是与用于构造reverse_iterator的迭代器类型相同的迭代器，但指向reverse_iterator当前指向的元素旁边的元素（reverse_iterator相对于其基迭代器的偏移量始终为 -1）。
// reverse_iterator::base example
#include // std::cout
#include // std::reverse_iterator
#include // std::vector
int main () {
std::vector myvector;
for (int i=0; i<10; i++) myvector.push_back(i);
typedef std::vector::iterator iter_type;
std::reverse_iterator rev_end (myvector.begin());
std::reverse_iterator rev_begin (myvector.end());
std::cout << "myvector:";
for (iter_type it = rev_end.base(); it != rev_begin.base(); ++it)
std::cout << ' ' << *it;
std::cout << '\n';
return 0;
} 3.operator*
返回对迭代器指向的元素的引用。
在内部，该函数减少其基本迭代器的副本，并返回取消引用它的结果。
迭代器应指向某个对象，以便可取消引用。
4.operator++
将reverse_iterator提升一个位置。
在内部，预增量版本 （1） 递减对象保留的基本迭代器（就像对它应用运算符一样）。
递增版本 （2） 的实现行为等效于：
reverse_iterator operator++(int) {
reverse_iterator temp = *this;
++(*this);
return temp;
}5.operator--
将reverse_iterator减少一个位置。
在内部，预递减版本 （1） 递增对象保留的基本迭代器（就像对其应用运算符 ++ 一样）。
递减后版本 （2） 的实现行为等效于：
reverse_iterator operator--(int) {
reverse_iterator temp = *this;
--(*this);
return temp;
}6.operator->
返回指向迭代器指向的元素的指针（以便访问其成员之一）。
pointer operator->() const {
return &(operator*());
}7.operator[]
访问距离迭代器当前指向的元素 n 个位置的元素。
如果此类元素不存在，则会导致未定义的行为。
在内部，该函数访问其基本迭代器的适当元素，返回与：base（）[-n-1] 相同的元素。
// reverse_iterator::operator[] example
#include // std::cout
#include // std::reverse_iterator
#include // std::vector
int main () {
std::vector myvector;
for (int i=0; i<10; i++) myvector.push_back(i); // myvector: 0 1 2 3 4 5 6 7 8 9
typedef std::vector::iterator iter_type;
std::reverse_iterator rev_iterator = myvector.rbegin();
std::cout << "The fourth element from the end is: " << rev_iterator[3] << '\n';
return 0;
} 3.反向迭代器的模拟实现
这里的反向迭代器与自定义的vector适配，定义了基本功能。
#pragma once
namespace wjc
{
template
struct Reverse_iterator
{
Iterator _it;
typedef Reverse_iterator self;
Reverse_iterator(Iterator it)
:_it(it)
{
}
Ref operator*()
{
Iterator tmp = _it;
return *(--tmp);
}
Ptr operator->()
{
return &(operator*());
}
self& operator++()//前置++
{
--_it;
return *this;
}
self& operator++(int)//后置++
{
--_it;
return *this;
}
self& operator--()//前置--
{
++_it;
return *this;
}
self& operator--(int)//后置--
{
++_it;
return *this;
}
bool operator!=(const self&s)
{
return _it != s._it;
}
};
template
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
typedef Reverse_iterator reverse_iterator;
typedef Reverse_iterator const_reverse_iterator;
const_reverse_iterator rebegin() const
{
return const_reverse_iterator(end());
}
const_reverse_iterator reend() const
{
return const_reverse_iterator(begin());
}
reverse_iterator rebegin()
{
return reverse_iterator(end());
}
reverse_iterator reend()
{
return reverse_iterator(begin());
}
vector()
: _start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
}
vector(const vector& v)
{
reserve(v.capacity());
for (const auto& e : v)
{
push_back(e);
}
}
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
size_t capacity()const
{
return _endofstorage - _start;
}
size_t size()const
{
return _finish - _start;
}
void push_back(const T& a)
{
if (_finish == _endofstorage)
{
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
}
*_finish = a;
_finish++;
}
void swap(vector& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
vector& operator=(vector v)
{
swap(v);
return *this;
}
~vector()
{
if (_start)
{
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
}
void reserve(size_t n)
{
if (n > capacity())
{
size_t oldsize = size();
T* tmp = new T[n];
if (_start)
{
/*memcpy(tmp, _start, sizeof(T) * oldsize);*/
for (size_t i = 0; i < oldsize; i++)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + oldsize;
_endofstorage = _start + n;
}
}
void resize(size_t n, T val = T())
{
if (n > size())
{
reserve(n);
while (_finish < _start + n)
{
*_finish = val;
++_finish;
}
}
else
{
_finish = _start + n;
}
}
void pop_back()
{
assert(size() > 0);
--_finish;
}
void insert(iterator pos, T x)
{
assert(pos <= _finish);
assert(pos >= _start);
size_t len = pos - _start;
if (_finish == _endofstorage)
{
reserve(capacity() == 0 ? 4 : capacity() * 2);//pos 扩容失效
//更新pos位置
pos = _start + len;
}
memmove(pos + 1, pos, (_finish - pos) * sizeof(T));
*pos = x;
++_finish;
}
void erase(iterator pos)
{
assert(pos < _finish);
assert(pos >= _start);
iterator it = pos + 1;
while (it < _finish)
{
*(it - 1) = *it;
++it;
}
_finish--;
}
T& operator[](size_t pos)
{
assert(pos, size());
return _start[pos];
}
const T& operator[](size_t pos)const
{
assert(pos, size());
return _start[pos];
}
template
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}
private:
iterator _start;
iterator _finish;
iterator _endofstorage;
};
} 测试
#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;
#include"iterator.h"
int main()
{
wjc::vector v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
v.push_back(6);
wjc::vector::reverse_iterator it = v.rebegin();
while (it != v.reend())
{
cout << *it << " ";
it++;
}
return 0;
} 
小结
在使用反向迭代器时要注意迭代器的失效问题，特别是在进行插入和删除操作时，要小心迭代器的有效性。
总之，反向迭代器是一个非常有用的工具，可以方便地逆序遍历容器中的元素，提供了在处理逆序数据时的便利。