STL 迭代器踩坑指南：写给每个被 Bug 折磨的 C++ 程序员

// vector迭代器失效示例 ⚠️
vector<int> vec = {1, 2, 3, 4, 5};
for(auto it = vec.begin(); it != vec.end(); ++it) {
    if(*it == 3) {
        vec.erase(it);  // 危险!后面的迭代器都失效了 ❌
        // it 变成了悬空迭代器
    }
}

// 正确的做法 ✅
for(auto it = vec.begin(); it != vec.end();) {
    if(*it == 3) {
        it = vec.erase(it);  // 使用erase返回的新迭代器
    } else {
        ++it;
    }
}

vector<int> vec = {1, 2, 3, 4, 5};
// 只读迭代器 👀
vector<int>::const_iterator cit = vec.cbegin();
// 可读写迭代器 ✏️
vector<int>::iterator it = vec.begin();
// 反向迭代器 ↩️
vector<int>::reverse_iterator rit = vec.rbegin();

容器类型    支持的迭代器类别
vector     随机访问迭代器 🎲
deque      随机访问迭代器 🎲
list       双向迭代器 ↔️
set/map    双向迭代器 ↔️
forward_list 前向迭代器 ➡️

// 随机访问迭代器像坐直升机 🚁,可以自由地跳转到任意位置
vector<int>::iterator vit = vec.begin();
vit += 3;  // 直接跳转3个位置,就像直升机起飞! ⬆️

// 双向迭代器就像步行 🚶,只能一步一步地移动
list<int>::iterator lit = mylist.begin();
++lit;  // 向前走一步 ➡️
--lit;  // 也可以后退一步 ⬅️

vector<int> numbers = {1, 2, 3, 4, 5};
for(auto it = numbers.begin(); it != numbers.end(); ++it) {
    if(*it % 2 == 0) {
        numbers.erase(it);  // 危险!这里是bug的源头 ⚠️
    }
}

// 方法一：使用erase的返回值 - 最推荐的方式! 🌟
vector<int> numbers = {1, 2, 3, 4, 5};
for(auto it = numbers.begin(); it != numbers.end();) {
    if(*it % 2 == 0) {
        it = numbers.erase(it);  // erase会返回下一个有效位置 ✨
    } else {
        ++it;  // 只有在不删除时才递增迭代器 ➡️
    }
}

// 方法二：从后向前遍历 - 巧妙避开了失效问题! 🧠
for(auto it = numbers.end(); it != numbers.begin();) {
    --it;  // 先后退一步 ⬅️
    if(*it % 2 == 0) {
        numbers.erase(it);  // 删除不会影响前面的元素 🎯
    }
}

list<int> numbers = {1, 2, 3, 4, 5};
for(auto it = numbers.begin(); it != numbers.end();) {
    if(*it % 2 == 0) {
        it = numbers.erase(it);  // 链表删除非常优雅 ✂️
    } else {
        ++it;  // 安全地移动到下一个节点 👉
    }
}

map<int, string> m = {{1,"one"}, {2,"two"}, {3,"three"}};
for(auto it = m.begin(); it != m.end();) {
    if(it->first % 2 == 0) {
        m.erase(it++);  // 高级技巧：删除当前节点但保留下一个位置 🎯
    } else {
        ++it;  // 正常遍历 ➡️
    }
}

vector<int> nums = {4, 1, 8, 5, 3, 7, 2, 9};

// 使用迭代器进行排序 - 就像给扑克牌排序一样 🎴
sort(nums.begin(), nums.end());

// 使用迭代器查找元素 - 像在图书馆找书一样 📚
auto it = find(nums.begin(), nums.end(), 5);
if(it != nums.end()) {
    cout << "找到元素: " << *it << endl;  // 欧耶!找到了 🎯
}

// 使用迭代器进行区间操作 - 像复制文件一样简单 📋
vector<int> target;
copy(nums.begin(), nums.begin() + 3, back_inserter(target));

// 自定义数据结构 - 像创建一个新的玩具模型 🎮
struct Student {
    string name;  // 学生姓名 📝
    int score;    // 学生分数 💯
};

vector<Student> students = {
    {"张三", 85},  // 创建学生档案 📋
    {"李四", 92},
    {"王五", 78}
};

// 使用迭代器和算法对自定义类型排序 - 像给运动员排名一样 🏆
sort(students.begin(), students.end(), 
    [](const Student& a, const Student& b) {
        return a.score > b.score;  // 分数高的排在前面 📊
    });

// 方式一：使用下标访问 - 像用页码找书一样 📖
vector<int> vec(10000000, 1);
for(size_t i = 0; i < vec.size(); ++i) {
    vec[i] *= 2;  // 直接翻到指定页码 📑
}

// 方式二：使用迭代器 - 像用书签一样 🔖
for(auto it = vec.begin(); it != vec.end(); ++it) {
    *it *= 2;  // 按顺序一页页翻阅 📚
}

vector<int> vec(1000000);  // 创建一个超大容器,就像准备一个大仓库 📦

// 糟糕的写法 - 就像用小铲子一勺一勺铲沙子 ⛏️
// 效率低下且容易出错! ⚠️
for(auto it = vec.begin(); it != vec.end(); ++it) {
    if(*it % 2 == 0) {
        vec.erase(it);  // 每次删除都会引发大量数据搬运 📦 ➡️ 📦
    }
}

// 优化后的写法 - 像开着推土机一次性推平 🚛
// 使用 erase-remove 习语,一气呵成! 🌪️
vec.erase(
    remove_if(vec.begin(), vec.end(), 
        [](int x) { return x % 2 == 0; }),  // 先标记要删除的元素 🎯
    vec.end()  // 然后一次性清除 🧹
);

// 不好的写法 - 像每走一步都要看一次山顶有多远 😓
for(auto it = vec.begin(); it != vec.end(); ++it) {
    // vec.end()会被重复调用 🔄
}

// 优化后的写法 - 提前规划好路线 🗺️
for(auto it = vec.begin(), end = vec.end(); it != end; ++it) {
    // 避免重复调用end() ✨
}

// 危险的写法 - 像在单行道上逆行 🚫
for(auto it = vec.begin(); it < vec.end(); ++it) {  
    // 不是所有迭代器都支持 < 运算符 ⚠️
}

// 安全的写法 - 遵守交通规则 🚦
for(auto it = vec.begin(); it != vec.end(); ++it) {
    // 使用 != 运算符更安全 ✅
}

// 展示迭代器适配器的强大功能 💪
vector<int> nums = {1, 2, 3, 4, 5};  // 准备数据 📝
ostream_iterator<int> out_it(cout, " ");  // 创建输出迭代器 📤
copy(nums.begin(), nums.end(), out_it);  // 优雅地输出 ✨

// 插入迭代器 - 像魔术师的帽子一样神奇 🎩
vector<int> dest;  // 准备一个容器 📦
back_insert_iterator<vector<int>> back_it(dest);  // 创建插入迭代器 ⬇️
// 或者使用更简便的方式
auto back_it = back_inserter(dest);  // 简洁优雅 ✨

// 反向迭代器 - 让世界倒着看 🔄
vector<int>::reverse_iterator rit = nums.rbegin();  // 从尾部开始 ⬅️

// 流迭代器 - 数据流的魔法使者 🌊
istream_iterator<int> in_it(cin);    // 输入流迭代器 📥
ostream_iterator<int> out_it(cout, ",");  // 输出流迭代器 📤

// 从文件读取数据 - 像抽取机器人在工作 🤖
ifstream input("data.txt");  // 打开文件 📂
vector<int> numbers;  // 准备容器 📦
copy(istream_iterator<int>(input),  // 开始读取 📥
     istream_iterator<int>(),       // 直到文件结束
     back_inserter(numbers));       // 自动插入 ⬇️

// 写入文件 - 数据存档专家 💾
ofstream output("output.txt");  // 创建输出文件 📄
copy(numbers.begin(),   // 从开始位置 
     numbers.end(),     // 到结束位置
     ostream_iterator<int>(output, "\n"));  // 优雅写入 📝

template<typename Container>
void processData(Container& c) {
    // 这里想用迭代器遍历容器,但不同容器的迭代器类型不一样 😕
    // 不知道该怎么写... 🤔
}

int main() {
    vector<int> vec = {1, 2, 3};  // 准备一个vector容器 📦
    list<int> lst = {4, 5, 6};    // 准备一个list容器 🔗
    processData(vec);  // 处理vector
    processData(lst);  // 处理list
}

template<typename Container>
void processData(Container& c) {
    // 使用迭代器萃取获取迭代器类型 🔍
    typename Container::iterator it;
    // 或者更现代的写法 ✨
    using Iterator = typename Container::iterator;
    
    // 获取迭代器的类别 - 就像查看生物的分类 🔬
    using Category = typenamestd::iterator_traits<Iterator>::iterator_category;
    
    // 根据迭代器类别选择不同的处理策略 - 像给不同动物选择合适的饲料 🐾
    if constexpr (std::is_same_v<Category, std::random_access_iterator_tag>) {
        // 针对随机访问迭代器的优化 - 像老鹰一样可以自由飞翔 🦅
        std::cout << "使用随机访问迭代器优化\n";
    } else {
        // 其他迭代器的通用处理 - 像陆地动物一步步走 🐢
        std::cout << "使用通用迭代器处理\n";
    }
}

template<typename Iterator>
void showIteratorInfo() {
    // 获取迭代器指向的值类型 - 像查看箱子里装的是什么 📦
    using ValueType = typenamestd::iterator_traits<Iterator>::value_type;
    
    // 获取迭代器的差值类型 - 测量两个迭代器之间的距离单位 📏
    using DiffType = typenamestd::iterator_traits<Iterator>::difference_type;
    
    // 获取指针类型 - 就像获取钥匙的类型 🔑
    using PointerType = typenamestd::iterator_traits<Iterator>::pointer;
    
    // 获取引用类型 - 类似于获取快捷方式的类型 🔗
    using RefType = typenamestd::iterator_traits<Iterator>::reference;
}

template<typename Iterator>
void advance_impl(Iterator& it, typename std::iterator_traits<Iterator>::difference_type n, 
                 std::random_access_iterator_tag) {
    it += n;  // 随机访问迭代器像飞机一样可以直接跳跃 ✈️
}

template<typename Iterator>
void advance_impl(Iterator& it, typename std::iterator_traits<Iterator>::difference_type n,
                 std::bidirectional_iterator_tag) {
    if (n >= 0) {
        while (n--) ++it;  // 双向迭代器像步行者一样需要一步步走 🚶♂️
    } else {
        while (n++) --it;  // 也可以后退,像螃蟹一样 🦀
    }
}

// 统一的接口,像一个智能调度中心 🎮
template<typename Iterator>
void my_advance(Iterator& it, typename std::iterator_traits<Iterator>::difference_type n) {
    // 根据迭代器类型自动选择最优实现 - 像智能交通系统 🚦
    advance_impl(it, n, typenamestd::iterator_traits<Iterator>::iterator_category());
}