@ohos-graphics/stability-code-review 0.1.0

package/references/BoundaryCondition/StabilityCodeReview_BoundaryCondition_008.md

@@ -0,0 +1,394 @@
+---
+rule_id: "StabilityCodeReview_BoundaryCondition_008"
+name: "容器erase后需正确更新迭代器"
+category: "边界条件"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 容器erase后需正确更新迭代器
+
+## 问题描述
+
+容器erase后需要正确更新迭代器，避免使用失效的迭代器。erase操作会使当前迭代器失效，继续使用会导致未定义行为、程序崩溃或内存访问错误。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 错误示例1：erase后继续使用迭代器
+void RemoveElements(std::vector<int>& vec)
+{
+    for (auto it = vec.begin(); it != vec.end(); ++it) {
+        if (*it < 0) {
+            vec.erase(it);  // 危险：erase后迭代器失效
+            ++it;  // 错误：使用失效的迭代器
+        }
+    }
+}
+
+// 错误示例2：erase后未更新迭代器
+void RemoveItems(std::list<int>& list)
+{
+    for (auto it = list.begin(); it != list.end(); ++it) {
+        if (*it == 0) {
+            list.erase(it);  // 危险：erase后迭代器失效
+        }
+    }
+}
+
+// 错误示例3：erase后直接访问
+void ProcessMap(std::map<int, std::string>& map)
+{
+    for (auto it = map.begin(); it != map.end(); ++it) {
+        if (it->second.empty()) {
+            map.erase(it);  // 危险：erase后迭代器失效
+            std::string key = std::to_string(it->first);  // 错误：访问失效迭代器
+        }
+    }
+}
+
+// 错误示例4：erase后继续遍历
+void RemoveBadItems(std::vector<Item>& items)
+{
+    for (auto it = items.begin(); it != items.end(); ++it) {
+        if (it->IsBad()) {
+            items.erase(it);  // 危险：迭代器失效
+            // 继续使用++it遍历
+        }
+    }
+}
+
+// 错误示例5：嵌套erase
+void RemoveNested(std::vector<std::vector<int>>& data)
+{
+    for (auto outer = data.begin(); outer != data.end(); ++outer) {
+        for (auto inner = outer->begin(); inner != outer->end(); ++inner) {
+            if (*inner == 0) {
+                outer->erase(inner);  // 危险：内层迭代器失效
+            }
+        }
+    }
+}
+
+// 错误示例6：erase后访问前一个元素
+void RemoveAndAccess(std::vector<int>& vec)
+{
+    auto prev = vec.begin();
+    for (auto it = vec.begin(); it != vec.end(); ++it) {
+        if (*it == 5) {
+            vec.erase(it);
+            int value = *prev;  // 错误：prev可能也已失效
+        }
+        prev = it;
+    }
+}
+
+// 错误示例7：set容器erase
+void RemoveSetItems(std::set<int>& set)
+{
+    for (auto it = set.begin(); it != set.end(); ++it) {
+        if (*it > 100) {
+            set.erase(it);  // 危险：迭代器失效
+        }
+    }
+}
+
+// 错误示例8：erase返回值未使用
+void RemoveValues(std::vector<int>& vec)
+{
+    for (auto it = vec.begin(); it != vec.end(); ++it) {
+        if (*it == 0) {
+            vec.erase(it);  // 错误：未使用erase返回值更新迭代器
+        }
+    }
+}
+
+// 错误示例9：删除后立即访问
+void RemoveAndCheck(std::list<int>& list)
+{
+    auto it = list.begin();
+    while (it != list.end()) {
+        if (*it == 0) {
+            list.erase(it);
+            if (it != list.end()) {  // 错误：it已失效
+                ++it;
+            }
+        } else {
+            ++it;
+        }
+    }
+}
+
+// 错误示例10：clear后使用迭代器
+void ClearAndAccess(std::vector<int>& vec)
+{
+    auto it = vec.begin();
+    vec.clear();  // 危险：所有迭代器失效
+    if (it != vec.end()) {  // 错误：使用失效迭代器
+        // ...
+    }
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 正确示例1：使用erase返回值更新迭代器
+void RemoveElements(std::vector<int>& vec)
+{
+    for (auto it = vec.begin(); it != vec.end(); ) {
+        if (*it < 0) {
+            it = vec.erase(it);  // 正确：使用返回值更新
+        } else {
+            ++it;  // 正确：只在未erase时递增
+        }
+    }
+}
+
+// 正确示例2：list容器erase更新
+void RemoveItems(std::list<int>& list)
+{
+    for (auto it = list.begin(); it != list.end(); ) {
+        if (*it == 0) {
+            it = list.erase(it);  // 正确：使用返回值
+        } else {
+            ++it;
+        }
+    }
+}
+
+// 正确示例3：map容器erase更新
+void ProcessMap(std::map<int, std::string>& map)
+{
+    for (auto it = map.begin(); it != map.end(); ) {
+        if (it->second.empty()) {
+            it = map.erase(it);  // 正确：使用返回值
+        } else {
+            ++it;
+        }
+    }
+}
+
+// 正确示例4：使用remove_if和erase组合
+void RemoveBadItems(std::vector<Item>& items)
+{
+    items.erase(
+        std::remove_if(items.begin(), items.end(), 
+            [](const Item& item) { return item.IsBad(); }),
+        items.end()
+    );
+}
+
+// 正确示例5：嵌套容器安全删除
+void RemoveNested(std::vector<std::vector<int>>& data)
+{
+    for (auto outer = data.begin(); outer != data.end(); ) {
+        for (auto inner = outer->begin(); inner != outer->end(); ) {
+            if (*inner == 0) {
+                inner = outer->erase(inner);  // 正确：使用返回值
+            } else {
+                ++inner;
+            }
+        }
+        if (outer->empty()) {
+            outer = data.erase(outer);  // 正确：使用返回值
+        } else {
+            ++outer;
+        }
+    }
+}
+
+// 正确示例6：使用索引而非迭代器
+void RemoveAndAccess(std::vector<int>& vec)
+{
+    for (size_t i = 0; i < vec.size(); ) {
+        if (vec[i] == 5) {
+            vec.erase(vec.begin() + i);  // 正确：索引访问安全
+        } else {
+            ++i;
+        }
+    }
+}
+
+// 正确示例7：set容器安全删除
+void RemoveSetItems(std::set<int>& set)
+{
+    for (auto it = set.begin(); it != set.end(); ) {
+        if (*it > 100) {
+            it = set.erase(it);  // 正确：使用返回值
+        } else {
+            ++it;
+        }
+    }
+}
+
+// 正确示例8：使用lambda和erase
+void RemoveValues(std::vector<int>& vec)
+{
+    vec.erase(std::remove(vec.begin(), vec.end(), 0), vec.end());
+}
+
+// 正确示例9：安全的while循环删除
+void RemoveAndCheck(std::list<int>& list)
+{
+    auto it = list.begin();
+    while (it != list.end()) {
+        if (*it == 0) {
+            it = list.erase(it);  // 正确：使用返回值
+        } else {
+            ++it;
+        }
+    }
+}
+
+// 正确示例10：clear后重新获取迭代器
+void ClearAndAccess(std::vector<int>& vec)
+{
+    vec.clear();
+    auto it = vec.begin();  // 正确：clear后重新获取迭代器
+    if (it != vec.end()) {
+        // ...
+    }
+}
+
+// 正确示例11：使用C++11的erase返回值
+template<typename Container, typename Predicate>
+void RemoveIf(Container& container, Predicate pred)
+{
+    for (auto it = container.begin(); it != container.end(); ) {
+        if (pred(*it)) {
+            it = container.erase(it);
+        } else {
+            ++it;
+        }
+    }
+}
+```
+
+## 检测范围
+
+检查以下模式：
+
+1. `container.erase(it)` 后使用 `++it`
+2. `container.erase(it)` 后访问 `*it` 或 `it->member`
+3. erase后未更新迭代器继续遍历
+4. clear后使用旧迭代器
+
+## 检测要点
+
+1. 识别`erase`函数调用
+2. 检查erase后是否使用返回值更新迭代器
+3. 检查erase后是否继续使用原迭代器
+4. 识别`clear`后迭代器使用
+5. 排除NOPROTECT标记的代码
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: erase操作后迭代器失效
+- **RISK_TYPE**: 使用失效迭代器
+- **RISK_PATH**: erase -> 迭代器失效 -> 继续使用 -> 未定义行为
+- **IMPACT_POINT**: 程序崩溃、内存访问错误
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: erase后未正确更新迭代器
+- **Propagation**: 失效迭代器导致内存访问错误
+- **Consequence**: 程序崩溃、数据损坏、未定义行为
+- **Mitigation**: 使用erase返回值更新迭代器，或使用remove_if
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT 标记 | 有 // NOPROTECT 注释 | 不报 |
+| 使用erase返回值 | it = container.erase(it) | 不报 |
+| remove_if模式 | 使用std::remove_if | 不报 |
+| 重新获取迭代器 | erase后重新begin() | 不报 |
+| 第三方库 | 位于 third_party 目录 | 白名单排除 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_BoundaryCondition_008_trigger.cpp
+void trigger_bad_1(std::vector<int>& vec)
+{
+    for (auto it = vec.begin(); it != vec.end(); ++it) {
+        if (*it < 0) {
+            vec.erase(it);  // 应该报：erase后++it
+            ++it;
+        }
+    }
+}
+
+void trigger_bad_2(std::list<int>& list)
+{
+    for (auto it = list.begin(); it != list.end(); ++it) {
+        if (*it == 0) {
+            list.erase(it);  // 应该报：erase后继续遍历
+        }
+    }
+}
+
+void trigger_bad_3(std::map<int, std::string>& map)
+{
+    for (auto it = map.begin(); it != map.end(); ++it) {
+        if (it->second.empty()) {
+            map.erase(it);
+            auto key = it->first;  // 应该报：访问失效迭代器
+        }
+    }
+}
+
+void trigger_bad_4(std::vector<int>& vec)
+{
+    auto it = vec.begin();
+    vec.clear();
+    if (it != vec.end()) {  // 应该报：clear后使用迭代器
+        // ...
+    }
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_BoundaryCondition_008_safe.cpp
+void safe_good_1(std::vector<int>& vec)
+{
+    for (auto it = vec.begin(); it != vec.end(); ) {
+        if (*it < 0) {
+            it = vec.erase(it);  // 安全：使用返回值
+        } else {
+            ++it;
+        }
+    }
+}
+
+void safe_good_2(std::vector<int>& vec)
+{
+    vec.erase(std::remove(vec.begin(), vec.end(), 0), vec.end());  // 安全：remove_if模式
+}
+
+void safe_good_3(std::set<int>& set)
+{
+    for (auto it = set.begin(); it != set.end(); ) {
+        if (*it > 100) {
+            it = set.erase(it);  // 安全：使用返回值
+        } else {
+            ++it;
+        }
+    }
+}
+
+// NOPROTECT: 特殊处理场景
+void noprotect_case(std::vector<int>& vec)
+{
+    for (auto it = vec.begin(); it != vec.end(); ++it) {
+        vec.erase(it);
+    }
+}
+```