C++标准模板（STL）- 迭代器库-迭代器适配器- 逆序遍历的迭代器适配器 （二）

迭代器库-迭代器原语

迭代器库提供了五种迭代器的定义，同时还提供了迭代器特征、适配器及相关的工具函数。

迭代器分类

迭代器共有五 (C++17 前)六 (C++17 起)种：遗留输入迭代器 (LegacyInputIterator) 、遗留输出迭代器 (LegacyOutputIterator) 、遗留向前迭代器 (LegacyForwardIterator) 、遗留双向迭代器 (LegacyBidirectionalIterator) 、遗留随机访问迭代器 (LegacyRandomAccessIterator) ，及 遗留连续迭代器 (LegacyContiguousIterator) (C++17 起)。

迭代器的分类的依据并不是迭代器的类型，而是迭代器所支持的操作。换句话说，某个类型只要支持相应的操作，就可以作为迭代器使用。例如，完整对象类型指针支持所有遗留随机访问迭代器 (LegacyRandomAccessIterator) 要求的操作，于是任何需要遗留随机访问迭代器 (LegacyRandomAccessIterator) 的地方都可以使用指针。

迭代器的所有类别（除了遗留输出迭代器 (LegacyOutputIterator) 和遗留连续迭代器 (LegacyContiguousIterator) ）能组织到层级中，其中更强力的迭代器类别（如遗留随机访问迭代器 (LegacyRandomAccessIterator) ）支持较不强力的类别（例如遗留输入迭代器 (LegacyInputIterator) ）的所有操作。若迭代器落入这些类别之一且亦满足遗留输出迭代器 (LegacyOutputIterator) 的要求，则称之为可变 迭代器并且支持输入还有输出。称非可变迭代器为常迭代器。

逆序遍历的迭代器适配器

std::reverse_iterator

std::reverse_iterator 是一个反转给定迭代器方向的迭代器适配器。换言之，提供双向迭代器时， std::reverse_iterator 产生一个新的迭代器，它从底层的双向迭代器所定义的序列的末尾移动到开端。

对于从迭代器 i 构造的 r 逆向迭代器，关系 &*r == &*(i-1) 始终为 true （只要 r 可解引用）；从而构造自末尾后一位置的迭代器的逆向迭代器解引用到序列的最后元素。

这是标准库容器的成员函数 rbegin() 及 rend() 所返回的迭代器。

构造新的迭代器适配器

std::reverse_iterator<Iter>::reverse_iterator

构造新的迭代器适配器。

1) 默认构造函数。值初始化底层迭代器。若且唯若值初始化的底层迭代器有受定义行为，产生的迭代器上的操作才一样有受定义行为。

2) 初始化底层迭代器为 x 。

3) 以 other 的底层迭代器初始化底层迭代器。

参数

 

赋值另一迭代器

std::reverse_iterator<Iter>::operator=

对底层迭代器赋 other 的底层迭代器的值，即 other.base() 。

参数

返回值

*this

调用示例

#include <iostream>
#include <string>
#include <iterator>
#include <deque>
#include <algorithm>
#include <typeinfo>
#include <time.h>
 
struct Cell
{
    int x;
    int y;
 
    Cell() = default;
    Cell(int a, int b): x(a), y(b) {}
 
    Cell &operator +=(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }
 
    Cell &operator +(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }
 
    Cell &operator *(const Cell &cell)
    {
        x *= cell.x;
        y *= cell.y;
        return *this;
    }
 
    Cell &operator ++()
    {
        x += 1;
        y += 1;
        return *this;
    }
 
    bool operator <(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y < cell.y;
        }
        else
        {
            return x < cell.x;
        }
    }
 
    bool operator ==(const Cell &cell) const
    {
        return x == cell.x && y == cell.y;
    }
};
 
std::ostream &operator<<(std::ostream &os, const Cell &cell)
{
    os << "{" << cell.x << "," << cell.y << "}";
    return os;
}
 
template< class BDIter >
void alg(BDIter, BDIter, std::input_iterator_tag)
{
    //遗留输入迭代器
    std::cout << "alg() called for input iterator" << std::endl;
}
 
template< class BDIter >
void alg(BDIter, BDIter, std::output_iterator_tag)
{
    //遗留输出迭代器
    std::cout << "alg() called for output iterator" << std::endl;
}
 
template< class BDIter >
void alg(BDIter, BDIter, std::forward_iterator_tag)
{
    //遗留向前迭代器
    std::cout << "alg() called for forward iterator" << std::endl;
}
 
template< class BDIter >
void alg(BDIter, BDIter, std::bidirectional_iterator_tag)
{
    //遗留双向迭代器
    std::cout << "alg() called for bidirectional iterator" << std::endl;
}
 
template <class RAIter>
void alg(RAIter, RAIter, std::random_access_iterator_tag)
{
    //遗留随机访问迭代器
    std::cout << "alg() called for random-access iterator" << std::endl;
}
 
template< class Iter >
void alg(Iter first, Iter last)
{
    alg(first, last,
        typename std::iterator_traits<Iter>::iterator_category());
}
 
int main()
{
    std::mt19937 g{std::random_device{}()};
 
    srand((unsigned)time(NULL));;
 
    std::cout << std::boolalpha;
 
    auto generate = []()
    {
        int n = std::rand() % 10 + 100;
        Cell cell{n, n};
        return cell;
    };
 
    std::deque<Cell> deque1(6);
    std::generate(deque1.begin(), deque1.end(), generate);
    std::cout << "deque1 :  ";
    std::copy(deque1.begin(), deque1.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
 
    std::cout << "deque1 reverse :  ";
    for (std::deque<Cell>::reverse_iterator rit = deque1.rbegin(); rit != deque1.rend(); rit++)
    {
        std::cout << *rit << " ";
    }
    std::cout << std::endl;
    alg(deque1.rbegin(), deque1.rend());
 
    //1) 默认构造函数。值初始化底层迭代器。
    //若且唯若值初始化的底层迭代器有受定义行为，产生的迭代器上的操作才一样有受定义行为。
    std::reverse_iterator<std::string::iterator> reverse_iterator;
    std::cout << typeid(reverse_iterator).name() << std::endl;
    alg(reverse_iterator, reverse_iterator);
 
    //2) 初始化底层迭代器为 x 。
    std::reverse_iterator<std::string::iterator> reverse_iterator1(reverse_iterator.base());
    std::cout << typeid(reverse_iterator1).name() << std::endl;
    alg(reverse_iterator1, reverse_iterator1);
 
    //3) 以 other 的底层迭代器初始化底层迭代器。
    std::reverse_iterator<std::string::iterator> reverse_iterator2(reverse_iterator);
    std::cout << typeid(reverse_iterator2).name() << std::endl;
    alg(reverse_iterator2, reverse_iterator2);
 
    //对底层迭代器赋 other 的底层迭代器的值，即 other.base() 。
    std::reverse_iterator<std::string::iterator> reverse_iterator3 = reverse_iterator;
    std::cout << typeid(reverse_iterator3).name() << std::endl;
    alg(reverse_iterator3, reverse_iterator3);
    return 0;
}

输出

deque1 :  {109,109} {109,109} {100,100} {106,106} {100,100} {101,101}
deque1 reverse :  {101,101} {100,100} {106,106} {100,100} {109,109} {109,109}
alg() called for random-access iterator
St16reverse_iteratorIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEE
alg() called for random-access iterator
St16reverse_iteratorIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEE
alg() called for random-access iterator
St16reverse_iteratorIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEE
alg() called for random-access iterator
St16reverse_iteratorIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEE
alg() called for random-access iterator