STL 迭代器iteratior 详解

C++的标准模板库（STL）中，迭代器是一种重要的工具，用于访问容器中的元素。

迭代器是一个变量，相当于容器和操纵容器的算法之间的中介。迭代器可以指向容器中的某个元素，通过迭代器就可以读写它指向的元素。从这一点上看，迭代器和指针类似。

分类

1) 正向迭代器，定义方法如下：

容器类名::iterator  迭代器名;

2) 常量正向迭代器，定义方法如下：

容器类名::const_iterator  迭代器名;

3) 反向迭代器，定义方法如下：

容器类名::reverse_iterator  迭代器名;

4) 常量反向迭代器，定义方法如下：

容器类名::const_reverse_iterator  迭代器名;

用法

通过迭代器指向它指向的元素， * 迭代器名就代表迭代器指向的元素。常量迭代器是只读权限，以const来修饰，非常量迭代器还能修改元素

++ 自增操作：

正向迭代器进行++操作，指向容器的后一个元素

反向迭代器进行++操作，则指向容器的前一个元素

我们通过迭代器来遍历容器中全部元素，一般来说有四种方式（本人习惯用）：

以下使用vector为例：

1. 基本的迭代器循环
2. C++11之后，增强版for
3. lambda表达式与for_each结合，需引用头文件  #include<algorithm>
4. 不需要修改容器元素的话,可以使用常量迭代器

#include<iostream>

//以vector为例

#include<vector>

// 需要使用for_eacj必须引入的算法库函数

#include<algorithm>



using namespace std;



// 遍历

void Test() {

    vector<int> v;

    v.push_back(20);

    v.push_back(10);

    v.push_back(5);



    // 1.基本的循环

    for (auto it = v.begin(); it !=  v.end(); ++it) {

        cout << *it << " ";

    }

    cout << endl;

    // 2.C++11之后，增强版for

    for (const auto& elem : v) {

        cout << elem << " ";

    }

    cout << endl;

    // 3.lambda表达式

    for_each(v.begin(), v.end(), [](int elem) { cout << elem << " "; });

    cout << endl;

    // 4.不需要修改容器元素的话,可以使用常量迭代器

    for (auto it = v.cbegin(); it != v.cend(); ++it) {

        cout << *it << " ";

    }

    cout << endl;

}



void Test_reverse() {

    vector<int> vec;

    for (int i = 0; i < 5; i++) {

        vec.push_back(i);

    }

    // 反向迭代器

    for (vector<int>::reverse_iterator it = vec.rbegin(); it != vec.rend(); ++it) {

        cout << *it << " ";

    }

    cout << endl;

    //lambda

    for_each(vec.rbegin(), vec.rend(), [](const auto& elem)-> void { cout << elem << " "; });

}



int main() {

    Test();

    Test_reverse();

    return 0;

}

程序运行结果是:

我们可能会疑惑，在使用基本循环时，为什么用前自增

无论是正向迭代器，还是反向迭代器

我们来回一下 ++重载成前置和后置运算符是这样的：

OPerator OPerator::operator++() {

    // 前置++

    ++n;

    return *this;

}

OPerator OPerator::operator++(int k) {

    // 后置++

    OPerator temp(*this);// 记录修改前的对象

    n++;

    return temp;

}

后置++的底层实现，我们要先保存一个对象temp，多了步骤，肯定执行速度慢于前置++。相同的，迭代器实质上也是一个对象，STL中，在重载迭代器的++运算符时，后置也是慢于前置的，一次可能相差不多，但在次数多的迭代中，差异就会变得明显了。

不同迭代器的具体操作

不同容器的迭代器，其功能强弱有所不同。容器的迭代器的功能强弱，决定了该容器是否支持 STL 中的某种算法。例如，排序算法需要通过随机访问迭代器来访问容器中的元素，因此有的容器就不支持排序算法。

常用的迭代器按功能强弱分为输入、输出、正向、双向、随机访问五种，这里只介绍常用的三种。

1) 正向迭代器。假设 p 是一个正向迭代器，则 p 支持以下操作：++p，p++，*p。此外，两个正向迭代器可以互相赋值，还可以用==和!=运算符进行比较。

2) 双向迭代器。双向迭代器具有正向迭代器的全部功能。除此之外，若 p 是一个双向迭代器，则--p和p--都是有定义的。--p使得 p 朝和++p相反的方向移动。

3) 随机访问迭代器。随机访问迭代器具有双向迭代器的全部功能。若 p 是一个随机访问迭代器，i 是一个整型变量或常量，则 p 还支持以下操作：

p+=i：使得 p 往后移动 i 个元素。

p-=i：使得 p 往前移动 i 个元素。

p+i：返回 p 后面第 i 个元素的迭代器。

p-i：返回 p 前面第 i 个元素的迭代器。

p[i]：返回 p 后面第 i 个元素的引用。

此外，两个随机访问迭代器 p1、p2 还可以用 <、>、<=、>= 运算符进行比较。p1<p2的含义是：p1 经过若干次（至少一次）++操作后，就会等于 p2。其他比较方式的含义与此类似。

对于两个随机访问迭代器 p1、p2，表达式p2-p1也是有定义的，其返回值是 p2 所指向元素和 p1 所指向元素的序号之差（也可以说是 p2 和 p1 之间的元素个数减一）。

模拟实现迭代器

（手撕套餐【包括： 正向迭代器，反向迭代器，常量正向迭代器，常量反向迭代器】）

我们还需要再模拟一个适配器，以达到使用统一的迭代器对不同的容器都能进行操作

我们知道，迭代器中提供的功能有：

1. 构造函数
2. operator++函数重载
3. operator++(int)函数重载
4. operator--函数重载
5. operator--(int)函数重载
6. operator*函数重载
7. operator->函数重载
8. operator!=函数重载
9. operator==函数重载