@ohos-graphics/stability-code-review 0.1.0

package/references/ResourceManagement/StabilityCodeReview_ResourceManagement_007.md

@@ -0,0 +1,395 @@
+---
+rule_id: "StabilityCodeReview_ResourceManagement_007"
+name: "智能指针与裸指针混用"
+category: "资源管理"
+severity: "CRITICAL"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 智能指针与裸指针混用
+
+## 问题描述
+
+C++标准库智能指针（unique_ptr、shared_ptr）、OpenHarmony sptr、裸指针(raw pointer)任意两两不能混用。混用会导致所有权不清晰，引发双重释放、内存泄漏、use after free等严重问题。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 场景1：unique_ptr::release后delete
+void bad_unique_release() {
+    std::unique_ptr<Foo> uptr(new Foo());
+    Foo* raw = uptr.release();  // 转移所有权到裸指针
+    // ... 使用raw
+    delete raw;  // 危险：裸指针管理，容易出错
+    // 如果后续代码继续使用uptr，会崩溃
+}
+
+// 场景2：对shared_ptr::get返回的指针delete
+void bad_shared_get_delete() {
+    std::shared_ptr<Foo> sptr = std::make_shared<Foo>();
+    Foo* raw = sptr.get();
+    delete raw;  // 严重错误：double free!
+    // shared_ptr析构时会再次delete
+}
+
+// 场景3：裸指针构造多个智能指针
+void bad_raw_multi_owner() {
+    Foo* raw = new Foo();
+    std::unique_ptr<Foo> uptr(raw);
+    std::shared_ptr<Foo> sptr(raw);  // 严重错误：double free!
+    // 两个智能指针都认为自己拥有所有权
+}
+
+// 场景4：shared_ptr和sptr混用
+void bad_sptr_shared() {
+    Foo* raw = new Foo();
+    sptr<Foo> oh_sptr(raw);
+    std::shared_ptr<Foo> std_sptr(raw);  // 严重错误：double free!
+}
+
+// 场景5：unique_ptr reset裸指针
+void bad_unique_reset() {
+    Foo* raw = new Foo();
+    std::unique_ptr<Foo> uptr;
+    // ... 一些代码
+    uptr.reset(raw);  // 危险：raw的所有权转移，但可能被其他地方释放
+}
+
+// 场景6：sptr和裸指针混用
+void bad_sptr_raw() {
+    Foo* raw = new Foo();
+    sptr<Foo> ptr(raw);
+    // ... 一些代码
+    delete raw;  // 严重错误：sptr已经管理，double free!
+}
+
+// 场景7：从unique_ptr获取裸指针后构造shared_ptr
+void bad_unique_to_shared() {
+    std::unique_ptr<Foo> uptr(new Foo());
+    Foo* raw = uptr.get();
+    std::shared_ptr<Foo> sptr(raw);  // 错误：所有权混乱
+    // uptr和sptr都认为自己拥有所有权
+}
+
+// 场景8：get()返回的指针用于构造另一个智能指针
+void bad_get_construct() {
+    std::shared_ptr<Foo> sptr1 = std::make_shared<Foo>();
+    std::shared_ptr<Foo> sptr2(sptr1.get());  // 错误：两个独立的引用计数
+    // sptr1和sptr2都会尝试delete同一个对象
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 修复场景1：保持unique_ptr管理
+void good_unique() {
+    std::unique_ptr<Foo> uptr = std::make_unique<Foo>();
+    uptr->DoSomething();
+    // unique_ptr自动释放，不需要手动delete
+}
+
+// 修复场景2：shared_ptr自动管理
+void good_shared() {
+    std::shared_ptr<Foo> sptr = std::make_shared<Foo>();
+    Foo* raw = sptr.get();  // 仅用于观察，不拥有所有权
+    raw->DoSomething();  // 可以使用，但不要delete
+    // shared_ptr自动释放
+}
+
+// 修复场景3：使用make_unique/make_shared
+void good_make() {
+    auto uptr = std::make_unique<Foo>();  // 推荐
+    auto sptr = std::make_shared<Foo>();  // 推荐
+    // 每个资源只有一个所有者
+}
+
+// 修复场景4：转移所有权用std::move
+void good_ownership_transfer() {
+    std::unique_ptr<Foo> uptr1 = std::make_unique<Foo>();
+    std::unique_ptr<Foo> uptr2 = std::move(uptr1);  // 正确：转移所有权
+    // uptr1变为nullptr，uptr2拥有所有权
+    
+    std::shared_ptr<Foo> sptr1 = std::make_shared<Foo>();
+    std::shared_ptr<Foo> sptr2 = sptr1;  // 正确：共享所有权，引用计数+1
+}
+
+// 修复场景5：使用shared_from_this
+class Foo : public std::enable_shared_from_this<Foo> {
+public:
+    std::shared_ptr<Foo> getShared() {
+        return shared_from_this();  // 正确：获取shared_ptr
+    }
+};
+
+// 修复场景6：sptr正确使用
+void good_sptr() {
+    sptr<Foo> ptr = new Foo();  // sptr管理
+    ptr->DoSomething();
+    // sptr自动释放
+    // 不要手动delete，不要用裸指针构造其他智能指针
+}
+
+// 修复场景7：明确所有权边界
+void process_foo(Foo* raw) {
+    // 函数签名表明：不获取所有权，仅观察
+    raw->DoSomething();
+    // 不delete
+}
+
+std::unique_ptr<Foo> create_foo() {
+    // 函数签名表明：返回所有权
+    return std::make_unique<Foo>();
+}
+
+// 修复场景8：使用weak_ptr打破循环引用
+class Bar {
+public:
+    std::weak_ptr<Bar> partner;  // 使用weak_ptr避免循环引用
+};
+
+void good_weak_ptr() {
+    auto bar1 = std::make_shared<Bar>();
+    auto bar2 = std::make_shared<Bar>();
+    bar1->partner = bar2;  // weak_ptr不增加引用计数
+    bar2->partner = bar1;
+    // 没有循环引用，正常释放
+}
+
+// 修复场景9：unique_ptr转shared_ptr
+void good_unique_to_shared() {
+    std::unique_ptr<Foo> uptr = std::make_unique<Foo>();
+    std::shared_ptr<Foo> sptr = std::move(uptr);  // 正确：转移所有权
+    // uptr变为nullptr，sptr拥有所有权
+}
+
+// 修复场景10：统一使用一种智能指针类型
+class ResourceManager {
+public:
+    // 推荐：统一使用shared_ptr
+    using Ptr = std::shared_ptr<Resource>;
+    
+    Ptr create() {
+        return std::make_shared<Resource>();
+    }
+    
+    void use(Ptr p) {
+        p->DoSomething();
+    }
+    
+    // 或者统一使用unique_ptr（性能更好）
+    using UniquePtr = std::unique_ptr<Resource>;
+    
+    UniquePtr createUnique() {
+        return std::make_unique<Resource>();
+    }
+};
+```
+
+## 检测范围
+
+检查以下混用模式：
+
+- `unique_ptr::release()` 后对裸指针操作
+- `shared_ptr::get()` 返回的指针被delete
+- 同一裸指针构造多个智能指针
+- `unique_ptr` 和 `shared_ptr` 相互转换不当
+- `sptr` 和 `std::shared_ptr` 混用
+- `reset()` 使用裸指针参数
+- `get()` 返回值用于构造新智能指针
+
+## 检测要点
+
+1. 识别智能指针变量声明
+2. 追踪裸指针变量来源
+3. 检测`release()`、`get()`的返回值使用
+4. 检测裸指针被多个智能指针管理
+5. 检测对`get()`返回值调用`delete`
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**：智能指针和裸指针混用
+- **RISK_TYPE**：资源管理混乱
+- **RISK_PATH**：智能指针管理 <-> 裸指针管理 -> 所有权冲突
+- **IMPACT_POINT**：双重释放、内存泄漏、程序崩溃
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**：同一资源被多个指针"拥有"
+- **Propagation**：所有权不清晰导致重复释放或泄漏
+- **Consequence**：double free、use after free、内存泄漏
+- **Mitigation**：统一使用一种智能指针类型，明确所有权
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| std::move转移所有权 | std::move(ptr) | 不报 |
+| shared_from_this | shared_from_this() | 不报 |
+| make_shared/make_unique | make_XXX() | 不报 |
+| weak_ptr | weak_ptr<T> | 不报 |
+| NOPROTECT标记 | 有 // NOPROTECT 注释 | 不报 |
+| 第三方库 | 位于 third_party 目录 | 白名单排除 |
+
+### release()的正确使用场景区分
+
+`release()`是所有权转移的正确方式，不应误报为"混用"：
+
+#### ✅ 安全场景（release()用于所有权转移）
+
+```cpp
+// 安全场景1：unique_ptr::release()转移所有权给裸指针，然后正确管理
+std::unique_ptr<Data> uptr = std::make_unique<Data>();
+Data* raw = uptr.release();  // uptr放弃所有权，raw接管
+// raw现在拥有唯一所有权，可以安全管理
+delete raw;  // 安全：raw是唯一所有者
+
+// 安全场景2：release()后交给C API管理
+std::unique_ptr<Buffer> buffer = CreateBuffer();
+C_API_Handle* handle = C_API_Create(buffer.release());  // 转移给C API
+// C API负责释放，不再需要手动delete
+
+// 安全场景3：release()返回所有权给调用者
+std::unique_ptr<Resource> CreateResource() {
+    auto uptr = std::make_unique<Resource>();
+    // 初始化资源
+    return uptr;  // 或 return uptr.release(); 返回裸指针让调用者选择管理方式
+}
+
+// 安全场景4：release()配合外部管理器
+std::unique_ptr<Node> node = std::make_unique<Node>();
+Node* rawPtr = node.release();
+externalManager.Register(rawPtr);  // 外部管理器接管所有权
+// externalManager负责释放
+```
+
+#### ❌ 危险场景（release()后所有权混乱）
+
+```cpp
+// 危险场景1：release()后裸指针被多个智能指针管理
+std::unique_ptr<Data> uptr = std::make_unique<Data>();
+Data* raw = uptr.release();
+std::shared_ptr<Data> sptr1(raw);  // ❌ sptr1管理raw
+std::shared_ptr<Data> sptr2(raw);  // ❌ sptr2也管理raw，double free
+
+// 危险场景2：release()后继续使用原unique_ptr
+std::unique_ptr<Data> uptr = std::make_unique<Data>();
+Data* raw = uptr.release();
+uptr.reset(raw);  // ❌ uptr重新管理raw，与裸指针所有权混乱
+
+// 危险场景3：release()后对已释放的裸指针操作
+std::unique_ptr<Data> uptr = std::make_unique<Data>();
+Data* raw = uptr.release();
+delete raw;
+raw->DoSomething();  // ❌ use after free
+```
+
+### 检测规则细化
+
+**release()应该报的情况**：
+- `release()`后裸指针被多个智能指针管理
+- `release()`后裸指针被delete，但原智能指针还在管理
+- `release()`后裸指针被reset回原智能指针
+
+**release()不应该报的情况**：
+- `release()`后裸指针正确管理（单一所有者）
+- `release()`用于转移所有权给外部API
+- `release()`作为函数返回值（调用者接管所有权）
+- `release()`配合外部管理器使用
+
+### 智能指针类型选择建议
+
+根据实际代码实践，推荐：
+
+1. **优先使用`std::make_unique/std::make_shared`**
+   - 避免`new`和裸指针
+   - 更安全，更高效
+
+2. **统一使用一种智能指针类型**
+   - 在同一模块内统一使用`shared_ptr`或`unique_ptr`
+   - 减少混用风险
+
+3. **使用`std::move`转移所有权**
+   - `unique_ptr`之间转移：`std::move(uptr)`
+   - `unique_ptr`到`shared_ptr`：`std::move(uptr)`
+
+4. **明确函数签名的所有权语义**
+   - 返回智能指针：调用者获得所有权
+   - 参数为智能指针：函数获得所有权或共享
+   - 参数为裸指针：仅观察，不管理
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_ResourceManagement_007_trigger.cpp
+void trigger_bad_1() {
+    std::unique_ptr<Foo> uptr(new Foo());
+    Foo* raw = uptr.release();  // 应该报：release后裸指针管理
+    delete raw;
+}
+
+void trigger_bad_2() {
+    std::shared_ptr<Foo> sptr = std::make_shared<Foo>();
+    Foo* raw = sptr.get();
+    delete raw;  // 应该报：对get返回值delete
+}
+
+void trigger_bad_3() {
+    Foo* raw = new Foo();
+    std::unique_ptr<Foo> uptr(raw);
+    std::shared_ptr<Foo> sptr(raw);  // 应该报：裸指针构造多个智能指针
+}
+
+void trigger_bad_4() {
+    Foo* raw = new Foo();
+    sptr<Foo> oh_sptr(raw);
+    std::shared_ptr<Foo> std_sptr(raw);  // 应该报：sptr和shared_ptr混用
+}
+
+void trigger_bad_5() {
+    std::shared_ptr<Foo> sptr1 = std::make_shared<Foo>();
+    std::shared_ptr<Foo> sptr2(sptr1.get());  // 应该报：get构造新shared_ptr
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_ResourceManagement_007_safe.cpp
+void safe_good_1() {
+    auto uptr = std::make_unique<Foo>();  // 安全：make_unique
+    uptr->DoSomething();
+}
+
+void safe_good_2() {
+    auto sptr = std::make_shared<Foo>();  // 安全：make_shared
+    Foo* raw = sptr.get();
+    raw->DoSomething();  // 安全：仅观察，不delete
+}
+
+void safe_good_3() {
+    std::unique_ptr<Foo> uptr = std::make_unique<Foo>();
+    std::shared_ptr<Foo> sptr = std::move(uptr);  // 安全：转移所有权
+}
+
+void safe_good_4() {
+    sptr<Foo> ptr = new Foo();  // 安全：sptr管理
+    ptr->DoSomething();
+}
+
+void safe_good_5() {
+    std::shared_ptr<Foo> sptr1 = std::make_shared<Foo>();
+    std::shared_ptr<Foo> sptr2 = sptr1;  // 安全：共享所有权
+}
+
+// NOPROTECT: 测试代码
+void noprotect_case() {
+    Foo* raw = new Foo();
+    std::unique_ptr<Foo> uptr(raw);
+    std::shared_ptr<Foo> sptr(raw);
+}
+```