C++标准模板（STL）- 迭代器库-迭代器原语-为迭代器各项性质提供统一接口

迭代器库-迭代器原语

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

迭代器分类

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

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

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

为迭代器各项性质提供统一接口

std::iterator_traits

template< class Iter > struct iterator_traits;
template< class T > struct iterator_traits<T*>;
template< class T > struct iterator_traits<const T*>;		(C++20 前)

std::iterator_traits 是类型特性类，为迭代器类型的属性提供统一的接口，使得能够仅针对迭代器实现算法。

该类定义了如下类型，与 std::iterator 中的类型定义相对应：

• difference_type - 可用来标识迭代器间距离的有符号整数类型
• value_type - 迭代器解除引用后所得到的值的类型。对于输出迭代器，该类型为 void 。
• pointer - 指向被迭代类型 (value_type) 的指针
• reference - 被迭代类型 (value_type) 的引用类型
• iterator_category - 迭代器类别。必须是迭代器类别标签之一。

可以针对用户自定义迭代器特化该模版，这样，即便该类型没有提供一般的类型定义，也能获取关于该迭代器的信息。

模版形参

Iter

-

需要取得与之相关属性的迭代器类型

成员类型

成员类型	定义
difference_type	Iter::difference_type
value_type	Iter::value_type
pointer	Iter::pointer
reference	Iter::reference
iterator_category	Iter::iterator_category

若 Iter 没有全部五个成员类型 difference_type 、 value_type 、 pointer 、 reference 及 iterator_category ，则此模板无任何有那些名称的成员（ std::iterator_traits 对 SFINAE 友好）

(C++17 起) (C++20 前)

若 Iter 无 pointer ，但拥有全部其他四个成员类型，则按如下方式声明成员类型： 成员类型 定义 difference_type Iter::difference_type value_type Iter::value_type pointer void reference Iter::reference iterator_category Iter::iterator_category 否则，若 Iter 满足仅为说明的概念 __LegacyInputIterator ，则按如下方式声明成员类型： 成员类型 定义 difference_type std::incrementable_traits<Iter>::difference_type value_type std::readable_traits<Iter>::value_type pointer 若合法则为 Iter::pointer ，否则若合法则为 decltype(​std::declval<Iter&>().operator->()) ，否则为 void reference 若合法则为 Iter::reference ，否则为 std::iter_reference_t<Iter> iterator_category 若合法则为 Iter::iterator_category ， 否则若 Iter 满足 __LegacyRandomAccessIterator 则为 std::random_access_iterator_tag ， 否则若 Iter 满足 __LegacyBidirectionalIterator 则为 std::bidirectional_iterator_tag ， 否则若 Iter 满足 __LegacyForwardIterator 则为 std::forward_iterator_tag ， 否则为 std::input_iterator_tag 否则，若 Iter 满足仅为说明的概念 __LegacyIterator ，则按如下方式声明成员类型： 成员类型 定义 difference_type 若合法则为 std::incrementable_traits<Iter>::difference_type ，否则为 void value_type void pointer void reference void iterator_category std::output_iterator_tag 否则，此模板无任何有这些名称的成员此模板无任何有那些名称的成员（ std::iterator_traits 对 SFINAE 友好）。

(C++20 起)

特化

如果要把用户提供的类型作为迭代器使用，该类型特征可以针对这一类型进行特化。标准库中提供了针对指针类型 T * 的两种偏特化，使得可以在任何需要迭代器的算法里使用裸指针。

T * 特化成员类型

仅若 std::is_object_v<T> 为 true 才特化。

(C++20 起)

成员类型	定义
difference_type	std::ptrdiff_t
value_type	T (C++20 前)std::remove_cv_t<T> (C++20 起)
pointer	T*
reference	T&
iterator_category	std::random_access_iterator_tag
iterator_concept(C++20 起)	std::contiguous_iterator_tag

const T * 特化成员类型 成员类型 定义 difference_type std::ptrdiff_t value_type T pointer const T* reference const T& iterator_category std::random_access_iterator_tag

(C++20 前)

 

调用示例

#include <iostream>
#include <string>
#include <iterator>
#include <algorithm>
#include <functional>
#include <time.h>
#include <vector>
#include <list>
#include <deque>

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
    {
        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 BidirIt>
void my_reverse(BidirIt first, BidirIt last)
{
    //获取首尾距离
    typename std::iterator_traits<BidirIt>::difference_type n = std::distance(first, last);
    --n;

    while (n > 0)
    {
        typename std::iterator_traits<BidirIt>::value_type tmp = *first;
        *first++ = *--last;
        *last = tmp;
        n -= 2;
    }
}

int main()
{
    std::vector<int> vector1{1, 2, 3, 4, 5};
    std::cout << "vector1:  ";
    std::copy(vector1.cbegin(), vector1.cend(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << std::endl;
    my_reverse(vector1.begin(), vector1.end());
    std::cout << "my_reverse:  ";
    std::copy(vector1.cbegin(), vector1.cend(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << std::endl;

    std::list<int> list1{1, 2, 3, 4, 5};
    std::cout << "list1:  ";
    std::copy(list1.cbegin(), list1.cend(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << std::endl;
    my_reverse(list1.begin(), list1.end());
    std::cout << "my_reverse:  ";
    std::copy(list1.cbegin(), list1.cend(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << std::endl;

    int iArray[] = {1, 2, 3, 4, 5};
    std::cout << "iArray:  ";
    std::copy(std::begin(iArray), std::end(iArray), std::ostream_iterator<int>(std::cout, " "));
    std::cout << std::endl;
    my_reverse(iArray, iArray + 5);
    std::cout << "my_reverse:  ";
    std::copy(std::begin(iArray), std::end(iArray), std::ostream_iterator<int>(std::cout, " "));
    std::cout << std::endl;

//    std::istreambuf_iterator<char> i1(std::cin), i2;
//    my_reverse(i1, i2); // 编译错误

    std::deque<Cell> deque1({Cell{101, 101}, Cell{102, 102},
                             Cell{103, 103}, Cell{104, 104}, Cell{105, 105}
                            });
    std::cout << "deque1:  ";
    std::copy(deque1.cbegin(), deque1.cend(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    my_reverse(deque1.begin(), deque1.end());
    std::cout << "my_reverse:  ";
    std::copy(deque1.cbegin(), deque1.cend(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    return 0;
}

输出

vector1:  1 2 3 4 5
my_reverse:  5 4 3 2 1
list1:  1 2 3 4 5
my_reverse:  5 4 3 2 1
iArray:  1 2 3 4 5
my_reverse:  5 4 3 2 1
deque1:  {101,101} {102,102} {103,103} {104,104} {105,105}
my_reverse:  {105,105} {104,104} {103,103} {102,102} {101,101}