vector<int> scores = {85, 90, 76, 88, 92};
// 想删除所有不及格的分数 (<60)
for (auto it = scores.begin(); it != scores.end(); ++it) {
    if (*it < 60) {
        scores.erase(it);   // ❌ 删除后 it 失效，再 ++it 是危险的！
    }
}

for (auto it = scores.begin(); it != scores.end(); ) {
    if (*it < 60) {
        it = scores.erase(it);   // ✅ erase返回新迭代器
    } else {
        ++it;
    }
}

vector<string> names = {"小明", "小红", "小刚"};
auto it = names.begin() + 1;   // 原来指向"小红"
// 在开头插入一个新名字
names.insert(names.begin(), "小华");   
// 此时 it 已经失效了！因为插入导致后面的元素后移
// cout << *it;  // 危险！可能输出"小红"也可能乱码
// 正确：重新获取迭代器
it = names.begin() + 2;   // 现在指向"小红"（因为前面多了一个"小华"）
cout << *it << endl;      // 输出 小红

vector<int> homework_scores;
homework_scores.reserve(100);   // 先预留100个位置
auto it = homework_scores.begin();  // 现在 it 指向 begin()（当前为空）
for (int i = 0; i < 50; ++i) {
    homework_scores.push_back(i * 2);
    // 只要不超过capacity（100），it 始终有效（依然指向 begin）
}
cout << *it << endl;   // 0，安全

#include <iterator>
vector<int> src = {1, 2, 3};
vector<int> dst = {10, 20, 30};
// 把src的所有元素插入dst的末尾
copy(src.begin(), src.end(), back_inserter(dst));
// dst 现在是 {10, 20, 30, 1, 2, 3}

vector<int> numbers = {0, 1, 2, 3, 4, 5};
auto it = numbers.begin();
while (it != numbers.end()) {
    if (*it % 2 == 0) {
        numbers.erase(it);   // 删除后 it 失效
    }
    ++it;   // 危险！
}

vector<int> v = {100, 200, 300};
auto it = v.begin() + 1;   // 指向200
v.insert(v.begin(), 0);    // 在开头插入0
// 现在 v 是 {0, 100, 200, 300}
cout << *it;   // 可能输出 100 而不是 200？因为 it 实际上指向了原来200的地址，但该地址现在存储的是100（因为后移）

vector<int> v;
v.reserve(10);
auto it = v.begin();   // 指向 begin（空）
v.push_back(1);
cout << *it;   // 哈？it 指向 begin()，但此时 begin() 已经变成了新元素1？实际上 v.begin() 并没有改变，但内容变了

#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <string>
using namespace std;

int main() {
    // ========== 1. vector 的失效场景 ==========
    cout << "=== vector 示例 ===" << endl;
    vector<int> vec = {1, 2, 3, 4, 5};
    auto it_vec = vec.begin() + 2;   // 指向3（下标2）
    cout << "原始迭代器 it_vec 指向：" << *it_vec << endl; // 3

    // 在末尾插入，可能重新分配
    vec.push_back(6);
    // ❌ 错误做法：继续用旧的 it_vec
    // cout << *it_vec; // 未定义行为！

    // ✅ 正确：重新获取
    it_vec = vec.begin() + 2;
    cout << "重新获取后 it_vec 指向：" << *it_vec << endl; // 3（仍在原位置）

    // 循环删除偶数（正确写法）
    vector<int> numbers = {0, 1, 2, 3, 4, 5};
    for (auto it = numbers.begin(); it != numbers.end(); ) {
        if (*it % 2 == 0) {
            it = numbers.erase(it);   // 删除后自动得到下一个迭代器
        } else {
            ++it;
        }
    }
    cout << "删除偶数后：";
    for (int x : numbers) cout << x << " "; // 1 3 5
    cout << endl;

    // ========== 2. list 的安全示范 ==========
    cout << "\n=== list 示例 ===" << endl;
    list<int> lst = {10, 20, 30, 40, 50};
    auto it1 = lst.begin();          // 指向10
    auto it2 = next(lst.begin());    // 指向20
    auto it3 = next(lst.begin(), 4); // 指向50

    lst.erase(lst.begin());          // 删除10，it1失效，但it2和it3仍然有效
    cout << "it2 指向：" << *it2 << endl; // 20
    cout << "it3 指向：" << *it3 << endl; // 50（没变）

    // 用 erase 返回值安全删除
    for (auto it = lst.begin(); it != lst.end(); ) {
        if (*it == 30) {
            it = lst.erase(it);   // 删除后 it 指向40
        } else {
            ++it;
        }
    }
    cout << "删除30后 list：";
    for (int x : lst) cout << x << " "; // 20 40 50
    cout << endl;

    // ========== 3. map 的失效规则 ==========
    cout << "\n=== map 示例 ===" << endl;
    map<string, int> stu_score = {{"小明", 90}, {"小红", 85}, {"小刚", 78}};
    auto it_map = stu_score.find("小红");
    cout << "it_map 指向：" << it_map->first << " => " << it_map->second << endl; // 小红 85

    // 插入一个新学生，不会影响已有迭代器
    stu_score.insert({"小华", 92});
    cout << "插入后 it_map 仍有效：" << it_map->first << " => " << it_map->second << endl; // 小红 85

    // 删除操作只使被删元素的迭代器失效
    stu_score.erase("小刚");   // 删除小刚的节点，指向小刚的迭代器会失效，但 it_map 仍然有效
    cout << "删除小刚后 it_map 仍有效：" << it_map->first << " => " << it_map->second << endl; // 小红 85

    // 如果删除 it_map 指向的元素，则 it_map 失效
    // stu_score.erase(it_map);  // 这么做后 it_map 就不能再用了

    // ========== 4. 使用 reserve 避免 vector 重新分配 ==========
    cout << "\n=== reserve 示例 ===" << endl;
    vector<int> big_vec;
    big_vec.reserve(500);   // 预留500个位置
    auto it_big = big_vec.begin();  // 此时 big_vec 为空，begin()==end()
    for (int i = 0; i < 500; ++i) {
        big_vec.push_back(i * 2);
        // 只要没超过500，it_big 还是有效吗？实际上 it_big 指向 begin()，而 push_back 没有改变 begin() 的地址（只要没重新分配）
        // 所以 it_big 仍然指向第一个元素（i=0时插入的元素）
    }
    cout << "it_big 现在指向：" << *it_big << endl; // 0，安全

    // 但是如果你把 big_vec 再 push_back 一次（超过500），就会重新分配，it_big 失效
    // big_vec.push_back(1000);   // 触发重新分配，下面的 cout 可能崩溃
    // cout << *it_big;  // 危险！

    return 0;
}

# 学生成绩列表，想删除所有 <60 分的学生
scores = [85, 45, 90, 32, 78, 55]

# ❌ 错误方式：用 for 循环直接删除
for i, score in enumerate(scores):
    if score < 60:
        del scores[i]    # 删除后后面的元素向前移，导致 i 索引不连续
print("错误结果：", scores)   # 可能是 [85, 90, 32, 78] 但少删了一个45？

# ✅ 正确方式1：用列表推导式创建新列表
scores = [85, 45, 90, 32, 78, 55]
scores = [s for s in scores if s >= 60]
print("正确结果（列表推导式）：", scores)  # [85, 90, 78]

# ✅ 正确方式2：用 while 循环手动控制索引
scores = [85, 45, 90, 32, 78, 55]
i = 0
while i < len(scores):
    if scores[i] < 60:
        del scores[i]    # 删除后 i 不加，因为后面的元素自动前移
    else:
        i += 1
print("正确结果（while循环）：", scores)  # [85, 90, 78]

# 字典例子：删除某个同学的记录
students = {"小明": 90, "小红": 85, "小刚": 78, "小华": 92}
# ❌ 错误方式
try:
    for name in students:
        if name == "小刚":
            del students[name]   # RuntimeError: dictionary changed size during iteration
except RuntimeError as e:
    print("字典迭代时修改出错：", e)

# ✅ 正确方式：复制键列表
students = {"小明": 90, "小红": 85, "小刚": 78, "小华": 92}
for name in list(students.keys()):   # 复制一份键的列表
    if name == "小刚":
        del students[name]
print("修改后字典：", students)  # {'小明': 90, '小红': 85, '小华': 92}

# 集合例子
scores_set = {85, 45, 90, 32, 78, 55}
# ❌ 错误方式
# for x in scores_set:
#     if x < 60:
#         scores_set.remove(x)   # RuntimeError
# ✅ 正确方式：用 set 推导式
scores_set = {x for x in scores_set if x >= 60}
print("正确集合：", scores_set)  # {90, 85, 78}