@ohos-graphics/stability-code-review 0.1.0

package/references/InitializationOrder/StabilityCodeReview_InitializationOrder_001.md

@@ -0,0 +1,411 @@
+---
+rule_id: "StabilityCodeReview_InitializationOrder_001"
+name: "类的数据成员需要显式初始化"
+category: "初始化顺序"
+severity: "MEDIUM"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 类的数据成员需要显式初始化
+
+## 问题描述
+
+类的数据成员如果没有显式初始化，且该类型没有默认构造函数，可能导致未定义行为或程序崩溃。即使是POD类型（如int、指针等），不显式初始化也会导致成员值不确定，在后续使用时可能产生不可预期的结果，严重影响系统稳定性。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 场景1：类成员未显式初始化（POD类型）
+class UserInfo {
+public:
+    int userId;           // 未初始化
+    int age;              // 未初始化
+    char* name;           // 未初始化
+    bool isActive;        // 未初始化
+    
+    void Print() {
+        printf("userId: %d, age: %d\n", userId, age);  // 未定义行为
+    }
+};
+
+// 场景2：类成员未显式初始化（无默认构造函数的类型）
+class Config {
+public:
+    std::string serverUrl;     // 有默认构造函数，可以不初始化
+    int port;                  // 未初始化
+    bool enabled;              // 未初始化
+    Logger* logger;            // 未初始化
+    
+    void Connect() {
+        if (enabled) {         // enabled值不确定
+            ConnectToServer(serverUrl.c_str(), port);  // port值不确定
+        }
+    }
+};
+
+// 场景3：结构体成员未初始化
+struct NetworkConfig {
+    int timeout;           // 未初始化
+    int retryCount;        // 未初始化
+    char* proxyHost;       // 未初始化
+    int proxyPort;         // 未初始化
+};
+
+NetworkConfig config;  // 所有成员值不确定
+
+// 场景4：嵌套类成员未初始化
+class Service {
+    class InnerConfig {
+    public:
+        int maxConnections;   // 未初始化
+        int timeout;          // 未初始化
+    };
+    
+    InnerConfig innerConfig;   // 内部类成员未初始化
+    int requestId;             // 未初始化
+    
+public:
+    void Process() {
+        for (int i = 0; i < innerConfig.maxConnections; i++) {  // 未定义行为
+            // ...
+        }
+    }
+};
+
+// 场景5：类数组未初始化
+class DataBuffer {
+    int buffer[1024];      // 数组未初始化
+    int count;             // 未初始化
+    
+public:
+    int GetCount() { return count; }  // 未定义行为
+};
+```
+
+### ✅ 修复方案
+
+```cpp
+// 修复场景1：类成员显式初始化（构造函数初始化列表）
+class UserInfo {
+public:
+    int userId;
+    int age;
+    char* name;
+    bool isActive;
+    
+    UserInfo() : userId(0), age(0), name(nullptr), isActive(false) {}
+    
+    void Print() {
+        printf("userId: %d, age: %d\n", userId, age);  // 安全
+    }
+};
+
+// 修复场景2：类成员显式初始化（类内初始化）
+class Config {
+public:
+    std::string serverUrl;     
+    int port = 8080;                  // C++11 类内初始化
+    bool enabled = false;             // C++11 类内初始化
+    Logger* logger = nullptr;         // C++11 类内初始化
+    
+    void Connect() {
+        if (enabled) {
+            ConnectToServer(serverUrl.c_str(), port);  // 安全
+        }
+    }
+};
+
+// 修复场景3：结构体成员初始化
+struct NetworkConfig {
+    int timeout = 30000;              // 默认值
+    int retryCount = 3;                // 默认值
+    char* proxyHost = nullptr;        // 默认值
+    int proxyPort = 0;                // 默认值
+};
+
+NetworkConfig config;  // 所有成员有确定值
+
+// 修复场景4：嵌套类成员初始化
+class Service {
+    class InnerConfig {
+    public:
+        int maxConnections = 100;     // 默认值
+        int timeout = 5000;           // 默认值
+    };
+    
+    InnerConfig innerConfig;
+    int requestId = 0;
+    
+public:
+    void Process() {
+        for (int i = 0; i < innerConfig.maxConnections; i++) {  // 安全
+            // ...
+        }
+    }
+};
+
+// 修复场景5：类数组初始化
+class DataBuffer {
+    int buffer[1024] = {0};   // 数组初始化为0
+    int count = 0;
+    
+public:
+    int GetCount() { return count; }  // 安全
+};
+
+// 修复场景6：使用默认构造函数
+class SafeConfig {
+public:
+    std::string serverUrl;           // 有默认构造函数
+    std::vector<int> ports;          // 有默认构造函数
+    std::map<int, std::string> data; // 有默认构造函数
+    
+    // 这些类型有默认构造函数，无需显式初始化
+};
+
+// 修复场景7：构造函数体内赋值
+class LegacyConfig {
+public:
+    int port;
+    bool enabled;
+    
+    LegacyConfig() {
+        port = 8080;       // 构造函数体内赋值
+        enabled = false;   // 构造函数体内赋值
+    }
+};
+```
+
+## 检测范围
+
+检查以下模式：
+
+- 类/结构体的数据成员声明（非静态成员变量）
+- 未使用类内初始化器（C++11）
+- 未在构造函数初始化列表中初始化
+- 未在构造函数体内赋值
+- 类型没有默认构造函数
+
+## 检测要点
+
+1. 识别类/结构体中的非静态数据成员
+2. 判断成员类型是否有默认构造函数
+3. 检查是否存在类内初始化器（`= value`）
+4. 检查构造函数初始化列表是否包含该成员
+5. 检查构造函数体内是否对该成员赋值
+6. 排除已有默认构造函数的类型（如std::string、std::vector等）
+
+### 初始化方式的优先级
+
+三种初始化方式的推荐优先级（从高到低）：
+
+1. **类内初始化器（C++11）** - 最高优先级
+   - 在成员声明时直接赋值：`int value = 0;`
+   - 优点：代码清晰、避免遗漏、支持所有构造函数
+   - 推荐用于：简单类型、常量默认值
+   - 示例：
+     ```cpp
+     class Config {
+         int port = 8080;          // 推荐
+         bool enabled = false;     // 推荐
+         std::string host = "";    // 推荐
+     };
+     ```
+
+2. **构造函数初始化列表** - 次优先级
+   - 在构造函数`: value(arg)`形式
+   - 优点：可接收参数、性能最优
+   - 推荐用于：需要参数初始化的成员、const成员
+   - 示例：
+     ```cpp
+     class Config {
+         int port;
+         Config(int p) : port(p) {}  // 推荐
+     };
+     ```
+
+3. **构造函数体内赋值** - 不推荐
+   - 在构造函数体`{ value = arg; }`
+   - 缺点：先默认初始化再赋值，效率较低
+   - 仅用于：无法使用初始化列表的场景
+   - 示例：
+     ```cpp
+     class LegacyConfig {
+         int port;
+         LegacyConfig(int p) {
+             port = p;  // 不推荐：先默认初始化再赋值
+         }
+     };
+     ```
+
+### POD类型与非POD类型的差异
+
+#### POD类型（Plain Old Data）- 必须显式初始化
+
+POD类型没有默认构造函数，未初始化时值为随机值：
+
+- **基本类型**：`int`, `long`, `float`, `double`, `char`, `bool`
+- **指针类型**：`int*`, `void*`, `char*`, `Logger*`
+- **枚举类型**：`enum Status { ... };`
+- **数组类型**：`int buffer[10];`
+
+**未初始化的后果**：
+```cpp
+int value;         // 未初始化，值可能是任意值（如-12345）
+bool flag;         // 未初始化，可能既不是true也不是false
+int* ptr;          // 未初始化，可能是野指针
+int arr[10];       // 未初始化，所有元素值不确定
+```
+
+**必须显式初始化**：
+```cpp
+int value = 0;              // ✅
+bool flag = false;          // ✅
+int* ptr = nullptr;         // ✅
+int arr[10] = {0};          // ✅
+```
+
+#### 非POD类型 - 通常有默认构造函数
+
+有默认构造函数的类型，不显式初始化时会调用默认构造函数：
+
+- **STL容器**：`std::string`, `std::vector`, `std::map`
+- **智能指针**：`std::unique_ptr`, `std::shared_ptr`
+- **自定义类**：有默认构造函数的类
+
+**可以不显式初始化**：
+```cpp
+std::string name;           // ✅ 调用默认构造，为空字符串
+std::vector<int> data;      // ✅ 调用默认构造，为空vector
+std::shared_ptr<Node> ptr;  // ✅ 调用默认构造，为nullptr
+```
+
+**建议显式初始化（更清晰）**：
+```cpp
+std::string name = "";              // ✅ 更清晰
+std::vector<int> data = {};         // ✅ 更清晰
+std::shared_ptr<Node> ptr = nullptr; // ✅ 更清晰
+```
+
+### 结构体初始化列表（C++11）
+
+C++11支持结构体的聚合初始化：
+
+```cpp
+struct NetworkConfig {
+    int timeout;
+    int retryCount;
+    char* proxyHost;
+    int proxyPort;
+};
+
+// 方式1：聚合初始化（使用默认值）
+NetworkConfig config1 = {30000, 3, nullptr, 0};  // ✅ 推荐
+
+// 方式2：类内初始化器（成员默认值）
+struct NetworkConfig {
+    int timeout = 30000;      // ✅ 推荐
+    int retryCount = 3;
+    char* proxyHost = nullptr;
+    int proxyPort = 0;
+};
+NetworkConfig config2;  // ✅ 使用类内默认值
+
+// 方式3：空初始化列表（零初始化）
+NetworkConfig config3 = {};  // ✅ 所有成员零初始化
+```
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**：类/结构体中未显式初始化的数据成员
+- **RISK_TYPE**：未定义行为、数据不一致
+- **RISK_PATH**：成员声明 -> 未初始化 -> 使用未定义值 -> 逻辑错误或崩溃
+- **IMPACT_POINT**：程序运行时行为不可预测、服务不稳定
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**：创建对象实例时，未初始化成员包含随机值
+- **Propagation**：使用未初始化成员的值进行计算、判断或访问
+- **Consequence**：程序行为不可预测、逻辑错误、内存访问错误、服务崩溃
+- **Mitigation**：为所有数据成员提供显式初始化（类内初始化器或构造函数初始化）
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| 有默认构造函数的类型 | std::string、std::vector等STL类型 | 不报 |
+| 有类内初始化器 | 成员声明有 `= value` | 不报 |
+| 在初始化列表初始化 | 构造函数 `: member(value)` | 不报 |
+| 在构造函数体赋值 | 构造函数内有 `member = value` | 不报 |
+| 静态成员 | static 声明 | 不报 |
+| const成员 | const 声明（必须在初始化列表） | 不报 |
+| NOPROTECT标记 | 有 // NOPROTECT 注释 | 不报 |
+| 第三方库 | 位于 third_party 目录 | 白名单排除 |
+| 测试代码 | 位于 test 目录 | 可选白名单 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_InitializationOrder_001_trigger.cpp
+class BadConfig {
+public:
+    int port;           // 应该报：未初始化
+    bool enabled;       // 应该报：未初始化
+    char* host;         // 应该报：未初始化
+    int count;          // 应该报：未初始化
+};
+
+struct NetworkInfo {
+    int timeout;        // 应该报：未初始化
+    int retryCount;     // 应应该报：未初始化
+};
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_InitializationOrder_001_safe.cpp
+class GoodConfig {
+public:
+    int port = 8080;              // 安全：类内初始化
+    bool enabled = false;         // 安全：类内初始化
+    char* host = nullptr;         // 安全：类内初始化
+    int count = 0;                // 安全：类内初始化
+};
+
+class SafeConfig {
+public:
+    int port;
+    bool enabled;
+    
+    SafeConfig() : port(8080), enabled(false) {}  // 安全：初始化列表
+};
+
+class AssignConfig {
+public:
+    int port;
+    bool enabled;
+    
+    AssignConfig() {
+        port = 8080;       // 安全：构造函数体赋值
+        enabled = false;
+    }
+};
+
+class STLConfig {
+public:
+    std::string name;      // 安全：有默认构造函数
+    std::vector<int> data;  // 安全：有默认构造函数
+};
+
+// NOPROTECT: 特殊场景
+// NOPROTECT: 测试代码
+class NoProtectConfig {
+public:
+    int value;  // 不报：有NOPROTECT标记
+};
+```

package/references/Lifecycle/StabilityCodeReview_Lifecycle_001.md

@@ -0,0 +1,255 @@
+---
+rule_id: "StabilityCodeReview_Lifecycle_001"
+name: "返回引用的函数返回局部变量"
+category: "生命周期"
+severity: "CRITICAL"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 返回引用的函数返回局部变量
+
+## 问题描述
+
+返回值类型是引用的函数，不应该返回局部变量，否则存在UAF(Use-After-Free)产生未定义行为。当函数返回局部变量的引用时，由于局部变量在函数返回后即被销毁，调用者获取的引用将指向已释放的栈内存，访问该引用将导致未定义行为，可能引发程序崩溃或数据损坏。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 场景1：返回局部变量的引用
+int& GetValue(int x) {
+    int value = x * 2;  // 局部变量
+    return value;       // 错误：返回局部变量的引用
+}
+
+// 场景2：返回局部数组元素的引用
+int& GetElement(int index) {
+    int arr[10];        // 局部数组
+    for (int i = 0; i < 10; i++) {
+        arr[i] = i;
+    }
+    return arr[index];  // 错误：返回局部数组元素的引用
+}
+
+// 场景3：返回条件表达式中局部变量的引用
+int& GetMax(int a, int b) {
+    int maxVal = (a > b) ? a : b;  // 局部变量
+    return maxVal;                  // 错误：返回局部变量的引用
+}
+
+// 场景4：返回局部对象的引用
+std::string& GetName() {
+    std::string name = "local";  // 局部对象
+    return name;                  // 错误：返回局部对象的引用
+}
+
+// 场景5：返回局部静态变量的引用（特殊场景）
+int& GetCounter() {
+    int counter = 0;  // 非静态局部变量
+    counter++;
+    return counter;   // 错误：每次调用都重新初始化
+}
+
+// 场景6：返回局部容器的引用
+std::vector<int>& GetValues() {
+    std::vector<int> values = {1, 2, 3};  // 局部容器
+    return values;                          // 错误：返回局部容器的引用
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 修复场景1：返回值而非引用
+int GetValue(int x) {
+    int value = x * 2;
+    return value;  // 正确：返回值
+}
+
+// 修复场景2：使用静态变量
+int& GetElement(int index) {
+    static int arr[10];  // 静态变量
+    for (int i = 0; i < 10; i++) {
+        arr[i] = i;
+    }
+    return arr[index];  // 正确：返回静态变量的引用
+}
+
+// 修复场景3：使用参数引用输出
+void GetMax(int a, int b, int& outMax) {
+    outMax = (a > b) ? a : b;  // 通过引用参数输出
+}
+
+// 修复场景4：返回静态或成员变量
+std::string& GetName() {
+    static std::string name = "local";  // 静态变量
+    return name;                        // 正确：返回静态变量的引用
+}
+
+// 修复场景5：正确使用静态变量
+int& GetCounter() {
+    static int counter = 0;  // 静态变量
+    counter++;
+    return counter;          // 正确：静态变量生命周期贯穿整个程序
+}
+
+// 修复场景6：返回指针或值
+std::vector<int> GetValues() {
+    std::vector<int> values = {1, 2, 3};
+    return values;  // 正确：返回值
+}
+
+// 修复场景7：返回成员变量的引用（实际代码中常见）
+class DataStore {
+private:
+    std::map<int, std::string> data_;
+    
+public:
+    const std::string& GetValue(int key) {
+        auto it = data_.find(key);
+        if (it != data_.end()) {
+            return it->second;  // ✅ 正确：返回成员变量map中的元素引用
+        }
+        static const std::string empty = "";
+        return empty;  // ✅ 正确：返回静态变量的引用
+    }
+    
+    std::map<int, std::string>& GetData() {
+        return data_;  // ✅ 正确：返回成员变量的引用
+    }
+};
+
+// 修复场景8：返回成员变量的成员引用（实际代码中常见）
+class Node {
+private:
+    struct Decoration {
+        Color backgroundColor_;
+    };
+    std::shared_ptr<Decoration> decoration_;
+    
+public:
+    const Color& GetBackgroundColor() {
+        if (decoration_) {
+            return decoration_->backgroundColor_;  // ✅ 正确：返回成员变量的成员
+        }
+        static Color defaultColor = Color::White();
+        return defaultColor;  // ✅ 正确：返回静态变量
+    }
+};
+
+// 修复场景9：单例模式的静态局部变量引用（Meyers单例）
+class MemoryTrack {
+public:
+    static MemoryTrack& Instance() {
+        static MemoryTrack instance;  // ✅ 正确：Meyers单例，静态局部变量
+        return instance;  // ✅ 正确：返回静态局部变量的引用，生命周期贯穿整个程序
+    }
+};
+
+// 修复场景10：返回智能指针管理的对象引用（需确保生命周期）
+class CacheManager {
+private:
+    std::shared_ptr<Image> cachedImage_;
+    
+public:
+    const Image& GetCachedImage() {
+        if (cachedImage_) {
+            return *cachedImage_;  // ✅ 正确：cachedImage_是成员，管理对象生命周期
+        }
+        static Image emptyImage;
+        return emptyImage;  // ✅ 正确：静态对象
+    }
+};
+```
+
+## 检测范围
+
+检查以下模式：
+
+- 返回类型包含 `&` 的函数
+- 返回语句中返回局部变量
+- 返回语句中返回临时对象
+- 返回语句中返回函数内的栈变量
+
+## 检测要点
+
+1. 识别函数返回类型是否为引用类型（包含 `&`）
+2. 追踪函数体内的局部变量定义
+3. 检测返回语句是否返回这些局部变量
+4. 排除返回静态变量、成员变量、参数引用、全局变量的情况
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**：函数返回类型声明为引用
+- **RISK_TYPE**：悬垂引用（Dangling Reference）/ UAF
+- **RISK_PATH**：返回局部变量引用 -> 函数返回栈帧销毁 -> 引用指向已释放内存 -> 访问导致UAF
+- **IMPACT_POINT**：调用者使用返回的引用时，访问已释放的栈内存
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**：函数返回后，调用者尝试使用返回的引用
+- **Propagation**：返回的引用指向已销毁的栈内存，内存可能被后续函数调用覆盖
+- **Consequence**：未定义行为，可能表现为随机值、程序崩溃、数据损坏、安全漏洞
+- **Mitigation**：返回值而非引用，或返回静态变量/成员变量的引用
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| 返回静态变量 | 变量声明含 `static` | 不报 |
+| 返回成员变量 | 返回 `this->member` 或 `member_` | 不报 |
+| 返回参数引用 | 返回参数本身或参数的成员 | 不报 |
+| 返回全局变量 | 返回全局/命名空间作用域变量 | 不报 |
+| NOPROTECT标记 | 有 `// NOPROTECT` 注释 | 不报 |
+| 第三方库 | 位于 `third_party` 目录 | 白名单排除 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_Lifecycle_001_trigger.cpp
+int& trigger_bad_1(int x) {
+    int value = x * 2;  // 应该报：返回局部变量引用
+    return value;
+}
+
+int& trigger_bad_2(int index) {
+    int arr[10];        // 应该报：返回局部数组元素引用
+    return arr[index];
+}
+
+std::string& trigger_bad_3() {
+    std::string name = "local";  // 应该报：返回局部对象引用
+    return name;
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_Lifecycle_001_safe.cpp
+int& safe_good_1(int index) {
+    static int arr[10];  // 安全：返回静态变量引用
+    return arr[index];
+}
+
+int& safe_good_2(int& param) {
+    return param;        // 安全：返回参数引用
+}
+
+class MyClass {
+public:
+    int& safe_good_3() {
+        return member_;   // 安全：返回成员变量引用
+    }
+private:
+    int member_;
+};
+
+int safe_good_4(int x) {
+    int value = x * 2;
+    return value;         // 安全：返回值而非引用
+}
+```