@ohos-graphics/stability-code-review 0.1.0

package/references/ResourceManagement/StabilityCodeReview_ResourceManagement_003.md

@@ -0,0 +1,420 @@
+---
+rule_id: "StabilityCodeReview_ResourceManagement_003"
+name: "禁止智能指针get初始化另一个智能指针"
+category: "资源管理"
+severity: "CRITICAL"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 禁止智能指针get初始化另一个智能指针
+
+## 问题描述
+
+禁止使用get初始化或赋值给另一个智能指针。从智能指针get()获取的裸指针再用来创建另一个智能指针，会导致两个智能指针管理同一个资源，析构时产生重复释放，造成程序崩溃。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 场景1：get()创建另一个shared_ptr - 双重释放
+void ProcessData()
+{
+    std::shared_ptr<Data> ptr1 = std::make_shared<Data>();
+    
+    // 错误：用get()创建另一个shared_ptr
+    std::shared_ptr<Data> ptr2(ptr1.get());  // 两个shared_ptr管理同一资源
+    
+    // ptr1析构释放资源
+    // ptr2析构再次释放同一资源 -> 双重释放崩溃
+}
+
+// 场景2：get()赋值给另一个shared_ptr
+void HandleResource()
+{
+    std::shared_ptr<Resource> original = std::make_shared<Resource>();
+    
+    // 错误：用get()赋值
+    std::shared_ptr<Resource> copy;
+    copy.reset(original.get());  // 双重管理
+    
+    // 两个shared_ptr都会尝试释放
+}
+
+// 场景3：函数返回get()指针被外部创建智能指针
+std::shared_ptr<File> GetFile()
+{
+    static std::shared_ptr<File> filePtr = std::make_shared<File>();
+    return filePtr;  // 正确：共享所有权
+}
+
+void UseFile()
+{
+    std::shared_ptr<File> ptr1 = GetFile();  // 正确
+    
+    // 错误：用get()创建新的智能指针
+    std::shared_ptr<File> ptr2(GetFile().get());  // 双重管理，崩溃风险
+}
+
+// 场景4：get()初始化unique_ptr - 更危险
+void ProcessUnique()
+{
+    std::shared_ptr<Data> sharedPtr = std::make_shared<Data>();
+    
+    // 错误：shared_ptr的get()初始化unique_ptr
+    std::unique_ptr<Data> uniquePtr(sharedPtr.get());  // unique_ptr会释放
+    
+    // sharedPtr析构时再次释放 -> 崩溃
+}
+
+// 场景5：成员函数返回get()被外部管理
+class ResourceManager {
+private:
+    std::shared_ptr<Resource> resource_;
+    
+public:
+    Resource* GetRaw() {
+        return resource_.get();  // 返回裸指针
+    }
+};
+
+void UseResource()
+{
+    ResourceManager mgr;
+    
+    // 错误：用返回的裸指针创建智能指针
+    std::shared_ptr<Resource> ptr(mgr.GetRaw());  // mgr.resource_析构时释放一次
+    // ptr析构时再释放一次 -> 崩溃
+}
+
+// 场景6：get()用于构造函数参数
+class DataProcessor {
+public:
+    DataProcessor(std::shared_ptr<Data> data) {
+        // 错误：假设调用者传入get()的结果
+        // 构造函数应该接收shared_ptr本身，而非裸指针
+    }
+};
+
+void Process()
+{
+    std::shared_ptr<Data> data = std::make_shared<Data>();
+    
+    // 错误：用get()构造
+    DataProcessor processor(std::shared_ptr<Data>(data.get()));
+}
+
+// 场景7：weak_ptr误用
+void WeakPtrMisuse()
+{
+    std::shared_ptr<Data> strongPtr = std::make_shared<Data>();
+    std::weak_ptr<Data> weakPtr = strongPtr;
+    
+    // 错误：用weak_ptr的lock().get()
+    if (auto locked = weakPtr.lock()) {
+        std::shared_ptr<Data> another(locked.get());  // 双重管理
+    }
+}
+
+// 场景8：容器中误用
+void ContainerMisuse()
+{
+    std::vector<std::shared_ptr<Data>> vec;
+    vec.push_back(std::make_shared<Data>());
+    
+    // 错误：从容器取get()创建新的智能指针
+    std::shared_ptr<Data> ptr(vec[0].get());  // vec中的shared_ptr和ptr双重管理
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 修复场景1：正确共享所有权
+void ProcessData()
+{
+    std::shared_ptr<Data> ptr1 = std::make_shared<Data>();
+    
+    // 正确：直接拷贝shared_ptr，共享所有权
+    std::shared_ptr<Data> ptr2 = ptr1;  // 引用计数增加
+    
+    // 只在最后一个shared_ptr析构时释放
+}
+
+// 修复场景2：正确赋值
+void HandleResource()
+{
+    std::shared_ptr<Resource> original = std::make_shared<Resource>();
+    
+    // 正确：直接赋值
+    std::shared_ptr<Resource> copy = original;  // 共享所有权
+}
+
+// 修复场景3：返回shared_ptr本身
+std::shared_ptr<File> GetFile()
+{
+    static std::shared_ptr<File> filePtr = std::make_shared<File>();
+    return filePtr;  // 正确：返回shared_ptr
+}
+
+void UseFile()
+{
+    std::shared_ptr<File> ptr = GetFile();  // 正确：共享所有权
+}
+
+// 修复场景4：不要混合管理
+void ProcessUnique()
+{
+    // 如果需要unique_ptr，直接创建
+    std::unique_ptr<Data> uniquePtr = std::make_unique<Data>();
+    
+    // 如果需要共享，用shared_ptr
+    std::shared_ptr<Data> sharedPtr = std::make_shared<Data>();
+    
+    // 不要混用
+}
+
+// 修复场景5：返回shared_ptr而非裸指针
+class ResourceManager {
+private:
+    std::shared_ptr<Resource> resource_;
+    
+public:
+    std::shared_ptr<Resource> GetShared() {
+        return resource_;  // 正确：返回shared_ptr
+    }
+    
+    Resource* GetRaw() {
+        return resource_.get();  // 仅用于观察，不管理
+    }
+};
+
+void UseResource()
+{
+    ResourceManager mgr;
+    
+    // 正确：获取shared_ptr共享所有权
+    std::shared_ptr<Resource> ptr = mgr.GetShared();
+}
+
+// 修复场景6：直接传递shared_ptr
+class DataProcessor {
+public:
+    DataProcessor(std::shared_ptr<Data> data) : data_(data) {}
+private:
+    std::shared_ptr<Data> data_;
+};
+
+void Process()
+{
+    std::shared_ptr<Data> data = std::make_shared<Data>();
+    
+    // 正确：直接传递shared_ptr
+    DataProcessor processor(data);
+}
+
+// 修复场景7：正确使用weak_ptr
+void WeakPtrCorrect()
+{
+    std::shared_ptr<Data> strongPtr = std::make_shared<Data>();
+    std::weak_ptr<Data> weakPtr = strongPtr;
+    
+    // 正确：lock()返回的shared_ptr直接使用
+    if (auto locked = weakPtr.lock()) {
+        // 直接使用locked，不要再用get()创建新的
+        locked->Process();
+    }
+}
+
+// 修复场景8：容器正确使用
+void ContainerCorrect()
+{
+    std::vector<std::shared_ptr<Data>> vec;
+    vec.push_back(std::make_shared<Data>());
+    
+    // 正确：直接拷贝shared_ptr
+    std::shared_ptr<Data> ptr = vec[0];  // 共享所有权
+}
+
+// 修复场景9：明确所有权转移
+void TransferOwnership()
+{
+    std::unique_ptr<Data> uniquePtr = std::make_unique<Data>();
+    
+    // 如果需要转移所有权给shared_ptr
+    std::shared_ptr<Data> sharedPtr(std::move(uniquePtr));  // 正确：move转移
+    
+    // uniquePtr现在为空，sharedPtr独占所有权
+}
+
+// 修复场景10：观察者模式正确使用
+void ObserverPattern()
+{
+    std::shared_ptr<Data> data = std::make_shared<Data>();
+    
+    // 观察者只使用裸指针观察，不管理
+    Data* observer = data.get();
+    observer->Inspect();  // 正确：仅观察
+    
+    // 不要用observer创建智能指针
+}
+```
+
+## 检测范围
+
+检查以下模式：
+
+- `std::shared_ptr<T>(ptr.get())`
+- `std::unique_ptr<T>(ptr.get())`
+- `ptr.reset(other.get())`
+- `std::shared_ptr<T>(obj->GetRaw())`（GetRaw返回get()）
+- `make_shared<T>(ptr.get())`
+- `make_unique<T>(ptr.get())`
+
+## 检测要点
+
+1. 识别`get()`方法调用
+2. 检查`get()`的结果是否用于创建智能指针
+3. 检测智能指针构造函数中使用`get()`的结果
+4. 检测`reset()`方法中使用`get()`的结果
+5. 排除合理使用的场景（如观察者模式）
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**：智能指针get()返回的裸指针
+- **RISK_TYPE**：双重释放
+- **RISK_PATH**：get() -> 新智能指针管理 -> 两个智能指针析构 -> 双重释放崩溃
+- **IMPACT_POINT**：程序崩溃、数据损坏
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**：使用get()创建另一个智能指针
+- **Propagation**：两个智能指针管理同一资源，析构时重复释放
+- **Consequence**：程序崩溃、堆损坏、数据丢失
+- **Mitigation**：正确共享所有权（拷贝shared_ptr）或使用std::move转移所有权
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| 观察者模式 | get()用于观察不创建智能指针 | 不报 |
+| 转移所有权 | std::move(unique_ptr)到shared_ptr | 不报 |
+| 老代码兼容 | 用于调用需要裸指针的API | 需检查不创建智能指针 |
+| NOPROTECT标记 | 有 // NOPROTECT 注释 | 不报 |
+| 第三方库 | 位于 third_party 目录 | 白名单排除 |
+
+### get()的正确使用场景区分
+
+`get()`方法本身是安全的，关键在于返回值的使用方式：
+
+#### ✅ 安全场景（get()用于观察）
+
+```cpp
+// 安全场景1：调用需要裸指针的API
+std::shared_ptr<Data> data = std::make_shared<Data>();
+LegacyAPI(data.get());  // 安全：仅观察，不创建新智能指针
+
+// 安全场景2：判断指针有效性
+std::shared_ptr<Node> node = GetNode();
+if (node.get() != nullptr) {  // 安全：仅判断有效性
+    node->Process();
+}
+
+// 安全场景3：传递给不管理所有权的函数
+void ObserverFunction(Data* rawPtr) {
+    rawPtr->Inspect();  // 仅观察，不delete，不创建智能指针
+}
+
+std::shared_ptr<Data> data = std::make_shared<Data>();
+ObserverFunction(data.get());  // 安全：函数不获取所有权
+```
+
+#### ❌ 危险场景（get()创建新智能指针）
+
+```cpp
+// 危险场景1：用get()创建新的shared_ptr
+std::shared_ptr<Data> ptr1 = std::make_shared<Data>();
+std::shared_ptr<Data> ptr2(ptr1.get());  // ❌ 双重管理，应报
+
+// 危险场景2：用get()赋值给另一个shared_ptr
+std::shared_ptr<Data> ptr1 = std::make_shared<Data>();
+std::shared_ptr<Data> ptr2;
+ptr2.reset(ptr1.get());  // ❌ 双重管理，应报
+
+// 危险场景3：用get()创建unique_ptr
+std::shared_ptr<Data> sharedPtr = std::make_shared<Data>();
+std::unique_ptr<Data> uniquePtr(sharedPtr.get());  // ❌ 混用，应报
+```
+
+### 检测规则细化
+
+**应该报的情况**：
+- `std::shared_ptr<T>(existingPtr.get())` - 构造函数参数
+- `std::unique_ptr<T>(existingPtr.get())` - 构造函数参数  
+- `newPtr.reset(existingPtr.get())` - reset参数
+- `std::make_shared<T>(existingPtr.get())` - make_shared参数
+- `std::make_unique<T>(existingPtr.get())` - make_unique参数
+
+**不应该报的情况**：
+- `LegacyAPI(ptr.get())` - API调用，不创建智能指针
+- `if (ptr.get() != nullptr)` - 仅判断有效性
+- `ObserverFunction(ptr.get())` - 函数参数，观察用途
+- `ptr.get()->Method()` - 通过裸指针调用方法，不创建智能指针
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_ResourceManagement_003_trigger.cpp
+void trigger_bad_1()
+{
+    auto ptr1 = std::make_shared<Data>();
+    std::shared_ptr<Data> ptr2(ptr1.get());  // 应该报：双重管理
+}
+
+void trigger_bad_2()
+{
+    std::shared_ptr<Resource> original = std::make_shared<Resource>();
+    std::shared_ptr<Resource> copy;
+    copy.reset(original.get());  // 应该报：双重管理
+}
+
+void trigger_bad_3()
+{
+    std::shared_ptr<Data> sharedPtr = std::make_shared<Data>();
+    std::unique_ptr<Data> uniquePtr(sharedPtr.get());  // 应该报：混用管理
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_ResourceManagement_003_safe.cpp
+void safe_good_1()
+{
+    auto ptr1 = std::make_shared<Data>();
+    std::shared_ptr<Data> ptr2 = ptr1;  // 安全：共享所有权
+}
+
+void safe_good_2()
+{
+    auto uniquePtr = std::make_unique<Data>();
+    std::shared_ptr<Data> sharedPtr(std::move(uniquePtr));  // 安全：转移所有权
+}
+
+void safe_good_3()
+{
+    auto data = std::make_shared<Data>();
+    Data* raw = data.get();  // 安全：仅观察
+    raw->Inspect();  // 不创建智能指针
+}
+
+// NOPROTECT: 特殊场景
+// NOPROTECT: 测试代码
+void noprotect_case()
+{
+    auto ptr1 = std::make_shared<Data>();
+    std::shared_ptr<Data> ptr2(ptr1.get());
+}
+```