反向迭代器与插入迭代器：让遍历和插入更轻松

从生活中的例子说起

想象你在听一首歌的播放列表，有时候你想从最后一首开始听，一首一首往前播放。手动把列表倒过来太麻烦，而播放器的“反向播放”功能就能直接搞定。反向迭代器就是C++里的“反向播放键”，它让你从容器（比如数组、列表）的末尾向开头逐个访问元素，不需要自己写递减循环。

再想象你在排队买东西，队伍很长，你拿了东西想往后加。如果有人专门负责自动把东西放到队伍末尾，你就不用操心该往哪里放。插入迭代器就是这样的“自动排队员”，它会帮你把新元素添加到容器的指定位置：末尾、开头，或者某个中间位置。这样，你在使用copy、generate等算法时，就不用手动管理容器的容量和位置，也不会越界。

一、反向迭代器：从后往前遍历的利器

1.1 基本概念

反向迭代器是一种迭代器适配器，它把普通迭代器的方向反转过来。如果你有一个容器，比如vector<int> vec = {1,2,3,4,5}，用vec.begin()指向1，vec.end()指向5之后的位置。而反向迭代器用vec.rbegin()指向5，vec.rend()指向1之前的位置。对反向迭代器执行++操作，实际上是向前移动，也就是向容器的头部移动。

所有支持双向或随机访问迭代器的容器（如vector、list、deque、set、map）都可以获得反向迭代器。

1.2 使用场景

逆序打印元素，比如打印考试分数从高到低（分数已按升序存储）。
从后往前查找最后一个匹配的元素，比如查找列表里最后一个不及格的分数。
配合算法实现逆序处理，比如用copy将容器内容逆序复制到另一个容器。

1.3 代码示例：从后往前遍历

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> scores = {60, 70, 80, 90, 100};   // 考试分数
    cout << "正向遍历：";
    for (auto it = scores.begin(); it != scores.end(); ++it)
        cout << *it << " ";
    cout << endl;

    cout << "反向遍历（从高到低）：";
    for (auto rit = scores.rbegin(); rit != scores.rend(); ++rit)
        cout << *rit << " ";
    cout << endl;

    // 查找最后一个80分的位置
    auto found = find(scores.rbegin(), scores.rend(), 80);
    if (found != scores.rend()) {
        // 反向迭代器转正向索引：索引 = rend() - found - 1
        int index = scores.rend() - found - 1;
        cout << "最后一个80分的位置（正向索引）: " << index << endl;
    }
    return 0;
}

1.4 新手容易犯的错误：反向迭代器的“断层”问题

反向迭代器有一个微妙的“错位”问题。如果你有一个正向迭代器it指向某个元素，你想把它转换成反向迭代器，需要小心。关系是：&*rit == &*(pos - 1)。也就是说，反向迭代器实际指向的“视觉位置”比正向迭代器靠后半格。

比如，vector<int> v = {10, 20, 30}，v.rbegin()指向30，v.rend()指向10前面的位置。如果你用v.rbegin() + 1，它指向的是20（因为++会逆向前进）。但如果你强行用reverse_iterator(v.begin())，它指向的其实是begin()之前一个位置（即无序位置），这是危险的。

常见错误：在使用insert或erase时传入反向迭代器。因为这些操作希望得到正向迭代器，不能直接传反向迭代器，需要先用.base()方法转换。例如：

vector<int> vec = {1,2,3,4,5};
auto rit = find(vec.rbegin(), vec.rend(), 3); // 找到最后一个3
if (rit != vec.rend()) {
    // 错误：vec.erase(rit);  // 不能直接传反向迭代器
    vec.erase(rit.base());   // 正确：rit.base() 返回正向迭代器，指向3后面的一个位置
}

理解.base()的偏移需要练习，不过日常使用rbegin()/rend()遍历就足够了，很少手动转换。

名称	函数	作用	需要容器的成员函数	示例
尾插	`back_inserter(c)`	在容器末尾添加元素	`push_back`	最常用，相当于队伍末尾加人
头插	`front_inserter(c)`	在容器开头添加元素	`push_front`	插队到最前面，只对`list`、`deque`有效
指定位置插	`inserter(c, pos)`	在指定位置之前添加元素	`insert`	像有人带你插到特定位置，几乎所有容器都支持

注意：front_inserter只用于支持push_front的容器（如list、deque），vector没有push_front，所以不能用。

2.3 代码示例：三种插入迭代器对比

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <iterator>
using namespace std;

int main() {
    // 准备源数据
    vector<int> src = {10, 20, 30};   // 源数据

    /***** (a) back_inserter：尾插 *****/
    vector<int> dest1;   // 空目标容器
    copy(src.begin(), src.end(), back_inserter(dest1));
    // dest1 变为 [10, 20, 30]
    cout << "back_inserter 结果：";
    for (int x : dest1) cout << x << " ";
    cout << endl;

    /***** (b) front_inserter：头插 *****/
    list<int> lst1 = {1, 2};   // 源容器
    list<int> lst2 = {3, 4};   // 目标容器
    copy(lst1.begin(), lst1.end(), front_inserter(lst2));
    // 注意：头插顺序反转！先插入1得到{1,3,4}，再插入2得到{2,1,3,4}
    cout << "front_inserter 结果：";
    for (int x : lst2) cout << x << " ";   // 输出 2 1 3 4
    cout << endl;

    /***** (c) inserter：指定位置插入 *****/
    list<int> lst3 = {100, 200, 300};   // 目标列表
    auto pos = lst3.begin();   // 指向100
    ++pos;                     // 指向200
    copy(src.begin(), src.end(), inserter(lst3, pos));
    // 在200之前依次插入10,20,30，得到 [100, 10, 20, 30, 200, 300]
    cout << "inserter 结果：";
    for (int x : lst3) cout << x << " ";
    cout << endl;

    /***** (d) 结合generate_n：自动生成序列 *****/
    vector<int> v;
    generate_n(back_inserter(v), 5, [n=0]() mutable { return n++; });
    // v 变为 [0,1,2,3,4]
    cout << "generate_n 结果：";
    for (int x : v) cout << x << " ";
    cout << endl;

    return 0;
}

2.4 常见错误与注意事项

front_inserter导致顺序反转：因为头插是每次插入到最前面，所以源序列的第一个元素会变成目标序列的最后一个。如果你希望保持顺序，不要用front_inserter，改用back_inserter再反转，或者用deque的push_front时注意。
inserter的位置迭代器不会自动更新：如果你在循环中反复使用同一个inserter，位置迭代器不会因为插入而改变。比如上面的例子中，pos指向200，插入10后，pos仍然指向200（因为list插入不使其他迭代器失效），所以10插入到200之前；然后20插入到200之前（即10之后），所以顺序是对的。但如果你希望每次插入到同一个位置（比如始终插入到第二个位置），需要每次重新计算迭代器。
不要对vector使用front_inserter：vector没有push_front，编译会报错。
插入迭代器是输出迭代器：只能用于写入，不能用于读取。比如你不能用*it获取值，只能给它赋值（*it = value）。

三、完整示例：用反向迭代器和插入迭代器实现逆序复制

下面这个例子综合运用了两种迭代器：将vector逆序复制到另一个vector中，用反向迭代器遍历源，用back_inserter作为目标。

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
using namespace std;

int main() {
    vector<int> src = {1, 2, 3, 4, 5};     // 源容器
    vector<int> dest;                      // 目标容器，初始为空

    // 将src逆序复制到dest：从后往前遍历，依次添加到dest末尾
    copy(src.rbegin(), src.rend(), back_inserter(dest));

    cout << "逆序复制结果：";
    for (int x : dest) cout << x << " ";   // 5 4 3 2 1
    cout << endl;

    return 0;
}

解释：src.rbegin()指向5，src.rend()指向1之前，copy依次取出5、4、3、2、1，通过back_inserter逐个追加到dest末尾，最终dest为{5,4,3,2,1}。

四、Python中的对应实现

Python虽然没有C++那种迭代器适配器，但有简单的替代：

反向遍历：reversed()返回一个迭代器。
尾插：list.append()。
头插：deque.appendleft()（需要collections.deque）。
指定位置插入：list.insert(index, value)。

# 反向遍历
vec = [1, 2, 3, 4, 5]
print(list(reversed(vec)))  # [5, 4, 3, 2, 1]

# 尾插模拟 back_inserter
src = [10, 20, 30]
dest = []
for x in src:
    dest.append(x)  # 等价于 back_inserter
print(dest)  # [10, 20, 30]

# 头插模拟 front_inserter（注意顺序反转）
from collections import deque
dq = deque([3, 4])
for x in [1, 2]:
    dq.appendleft(x)   # 依次插入1,2，得到 [2,1,3,4]
print(list(dq))  # [2, 1, 3, 4]

# 指定位置插入模拟 inserter
lst = [100, 200, 300]
pos = 1  # 在索引1之前插入
for i, x in enumerate([10, 20, 30]):
    lst.insert(pos + i, x)  # 每次插入后，位置向后移动
print(lst)  # [100, 10, 20, 30, 200, 300]

五、总结与延伸

反向迭代器：用rbegin()/rend()获取，实现从尾到头的遍历。注意“断层”问题，转换时用.base()。
插入迭代器：三种类型，分别对应尾插、头插、指定位置插。常与copy、generate、transform等算法配合，安全地扩展容器。
常见坑：front_inserter顺序反转；对vector不能头插；inserter的位置迭代器需要注意是否失效。
相关知识点：迭代器失效、算法copy、transform、generate、容器vector与list的区别。

掌握了这些特殊的迭代器，你就能写出更简洁、更安全的C++代码，不用再手动管理循环和容器大小。下一节，我们来聊聊实际开发中常遇到的另一个问题——迭代器失效。

反向迭代器与插入迭代器