C++ 用 13 条规则让模型写出安全现代 C++

为什么需要规则？

在 AI 辅助编程的时代，大型语言模型（LLM）已成为 C++ 开发者不可或缺的伙伴。然而，模型生成的代码往往存在安全隐患、风格过时或与现代 C++（C++11/14/17/20）最佳实践相悖的问题。直接使用这些代码可能导致内存泄漏、未定义行为、性能瓶颈或难以维护的代码库。

本文提出 13 条核心规则 ，旨在引导和约束 AI 模型（如 GPT-4、Claude、CodeLlama 等）生成安全、现代、高效且可维护的 C++ 代码。这些规则覆盖了资源管理、类型安全、API 设计、并发和代码风格等关键领域，每一条都配有原理说明、反面示例、正面示例以及给模型的明确指令模板。

规则 1：优先使用智能指针，禁止裸 `new`/`delete`

原理： 手动内存管理是 C++ 中错误和资源泄漏的主要来源。`std::unique_ptr` 和 `std::shared_ptr` 提供了自动的、异常安全的资源释放。

给模型的指令： "生成 C++ 代码时，对于动态分配的对象，必须使用 `std::unique_ptr` 或 `std::shared_ptr`。禁止使用裸 `new` 和 `delete` 运算符。如果函数需要传递所有权，使用 `std::unique_ptr`；如果需要共享所有权，使用 `std::shared_ptr`。"

反面示例：

cpp 复制代码

// ❌ 危险：手动管理内存，易泄漏
MyClass* obj = new MyClass();
try {
    obj->doSomething();
} catch (...) {
    // 异常时可能忘记 delete
    delete obj;
    throw;
}
delete obj;

正面示例：

cpp 复制代码

// ✅ 安全：使用 unique_ptr，异常安全
auto obj = std::make_unique<MyClass>();
obj->doSomething();
// 无需手动 delete，离开作用域自动释放

规则 2：使用 `const` 和 `constexpr` 最大化不变性

原理： `const` 提高了代码的可读性和安全性，防止意外修改。`constexpr` 允许在编译期计算值，提升性能并启用编译期检查。

给模型的指令： "默认将变量、函数参数和成员函数声明为 `const`，除非它们需要被修改。对于编译期可知的值，使用 `constexpr`。对于成员函数，如果不修改对象状态，应声明为 `const`。"

反面示例：

cpp 复制代码

// ❌ 模糊：哪些参数会被修改？
void processData(int width, int height, std::vector<int>& buffer);

正面示例：

cpp 复制代码

// ✅ 清晰：意图明确
void processData(const int width,
                 const int height,
                 const std::vector<int>& buffer) const; // 成员函数不修改对象

constexpr int kBufferSize = 1024; // 编译期常量

规则 3：使用范围 `for` 循环 (`for (auto&& item : range)`)

原理： 范围 `for` 循环更简洁、更安全（不易出现越界错误），并且能自动推导类型。它适用于所有提供 `begin()` 和 `end()` 的容器。

给模型的指令： "遍历标准库容器（如 `vector`, `map`, `set`）、数组或任何范围时，必须使用范围 `for` 循环 (`for (auto&& item : range)`)。避免使用基于索引或迭代器的传统 `for` 循环，除非需要访问索引或进行复杂迭代控制。"

反面示例：

cpp 复制代码

// ❌ 冗长且易错
std::vector<int> vec = {1, 2, 3};
for (std::size_t i = 0; i < vec.size(); ++i) {
    std::cout << vec[i] << std::endl;
}

正面示例：

cpp 复制代码

// ✅ 简洁安全
std::vector<int> vec = {1, 2, 3};
for (const auto& value : vec) {
    std::cout << value << std::endl;
}
// 需要修改元素时
for (auto& value : vec) {
    value *= 2;
}

规则 4：使用 `std::string_view` 代替 `const std::string&` 或 `const char*` 作为只读字符串参数

原理： `std::string_view`（C++17）是一个非拥有的、只读的字符串视图，避免了不必要的 `std::string` 构造和拷贝，性能更高，且能同时接受 `std::string` 和 C 风格字符串。

给模型的指令： "当函数只需要读取字符串内容，而不需要获取所有权或修改底层数据时，参数类型应使用 `std::string_view`。不要使用 `const std::string&` 或 `const char*` 作为只读字符串参数。"

反面示例：

cpp 复制代码

// ❌ 可能引发不必要的拷贝
void printString(const std::string& str);
// 调用时：printString("Hello"); // 隐式构造临时 std::string

正面示例：

cpp 复制代码

// ✅ 高效，无拷贝
void printString(std::string_view str) {
    std::cout << str << std::endl;
}
// 可以接受多种输入
std::string s = "Hello";
printString(s); // OK
printString("World"); // OK，无需构造临时 string
printString(s.substr(0, 3)); // OK

规则 5：使用 `std::optional` 明确表示"可能有值"

原理： 使用特殊值（如 `-1`、`nullptr`、空字符串）表示"无值"容易出错且不清晰。`std::optional`（C++17）类型安全地表达了可选值，编译器能强制检查。

给模型的指令： "当一个值可能存在也可能不存在时，使用 `std::optional<T>` 作为返回类型或成员变量。禁止使用 `nullptr`、`-1` 等魔术数字或布尔标志来表示'无值'状态。"

反面示例：

cpp 复制代码

// ❌ 模糊：-1 代表什么？错误？未找到？
int findIndex(const std::vector<int>& vec, int target) {
    // ...
    return -1; // 表示未找到
}

正面示例：

cpp 复制代码

// ✅ 清晰且类型安全
std::optional<std::size_t> findIndex(const std::vector<int>& vec, int target) {
    auto it = std::find(vec.begin(), vec.end(), target);
    if (it != vec.end()) {
        return std::distance(vec.begin(), it);
    }
    return std::nullopt; // 明确表示"无值"
}
// 调用方必须检查
auto idx = findIndex(vec, 42);
if (idx) {
    std::cout << "Found at: " << *idx << std::endl;
} else {
    std::cout << "Not found" << std::endl;
}

规则 6：使用 `std::variant` 代替裸联合体或继承层次

原理： 裸 `union` 类型不安全，需要手动管理活跃成员。`std::variant`（C++17）是类型安全的联合体，提供了访问者模式等安全访问方式。

给模型的指令： "当需要表示一个值可以是几种不同类型之一时，使用 `std::variant`。禁止使用 C 风格的 `union`。对于简单的'要么是 A，要么是 B'的场景，优先考虑 `std::variant` 而非设计复杂的继承体系。"

反面示例：

cpp 复制代码

// ❌ 危险：需要手动跟踪活跃类型
union Data {
    int i;
    double d;
    char* s;
};
Data data;
data.i = 42;
// 错误：以 double 方式读取 int
std::cout << data.d; // 未定义行为！

正面示例：

cpp 复制代码

// ✅ 类型安全
std::variant<int, double, std::string> data;
data = 42; // 存储 int
data = 3.14; // 现在存储 double，之前的值被正确销毁

// 安全访问
std::visit([](auto&& arg) {
    using T = std::decay_t<decltype(arg)>;
    if constexpr (std::is_same_v<T, int>) {
        std::cout << "int: " << arg << std::endl;
    } else if constexpr (std::is_same_v<T, double>) {
        std::cout << "double: " << arg << std::endl;
    } else if constexpr (std::is_same_v<T, std::string>) {
        std::cout << "string: " << arg << std::endl;
    }
}, data);

规则 7：使用 ` $\[nodiscard$ ]` 属性标记不应忽略返回值的函数

原理： 许多函数（如工厂函数、错误检查函数）的返回值非常重要，忽略它们通常是编程错误。` $\[nodiscard$ ]` 属性（C++17）让编译器在返回值被忽略时发出警告。

给模型的指令： "对于其返回值必须被检查或使用的函数（如创建新对象的工厂函数、可能失败的操作、计算纯函数），应添加 ` $\[nodiscard$ ]` 属性。这包括构造函数（如果定义了移动或拷贝操作）。"

反面示例：

cpp 复制代码

// ❌ 错误容易被忽略
std::unique_ptr<Resource> createResource(); // 调用者可能忘记接收返回值
createResource(); // 资源泄漏！

正面示例：

cpp 复制代码

// ✅ 编译器会警告
[[nodiscard]] std::unique_ptr<Resource> createResource() {
    return std::make_unique<Resource>();
}
// 调用时忽略返回值会触发编译器警告
// createResource(); // 警告：忽略 nodiscard 函数的返回值

规则 8：使用结构化绑定 (`auto $a, b$ = ...`)

原理： 结构化绑定（C++17）可以简洁地将元组、对或结构体的成员解包到变量中，提高代码可读性。

给模型的指令： "当从 `std::pair`、`std::tuple`、`std::array` 或结构体返回多个值时，在调用方使用结构化绑定 (`auto $x, y$ = func()`) 来接收它们。避免使用 `std::tie` 或手动访问 `.first`/`.second`。"

反面示例：

cpp 复制代码

// ❌ 冗长
std::pair<bool, std::string> result = validate(input);
bool success = result.first;
std::string message = result.second;

正面示例：

cpp 复制代码

// ✅ 清晰直观
auto [success, message] = validate(input);
// 直接使用 success 和 message
if (!success) {
    std::cerr << "Error: " << message << std::endl;
}

规则 9：使用 `std::span` 作为连续序列的视图参数

原理： `std::span`（C++20）是一个轻量级的、非拥有的连续序列视图，可以统一表示数组、`std::vector`、`std::array` 等，避免传递指针和大小分开的参数。

给模型的指令： "当函数需要操作一个连续的、只读或可写的元素序列（如数组、vector 的数据）时，使用 `std::span<T>` 或 `std::span<const T>` 作为参数类型。禁止使用 `T*` 加 `size_t` 的参数对。"

反面示例：

cpp 复制代码

// ❌ 容易出错：需要手动管理指针和大小
void processArray(int* data, std::size_t size);

正面示例：

cpp 复制代码

// ✅ 安全且表达力强
void processArray(std::span<int> data) {
    for (auto& elem : data) { // 可直接用范围 for
        elem *= 2;
    }
}
// 调用灵活
std::vector<int> vec = {1, 2, 3};
processArray(vec); // 整个 vector

int arr[] = {4, 5, 6};
processArray(arr); // 原生数组

processArray({vec.data() + 1, 2}); // 子范围

规则 10：使用 `constinit` 和 `consteval` 强化编译期行为 (C++20)

原理： `constinit` 确保静态或线程局部变量在编译期初始化，避免静态初始化顺序问题。`consteval` 指定函数必须在编译期求值，用于真正的编译期计算。

给模型的指令： "对于需要在编译期初始化的静态或线程局部变量，使用 `constinit` 确保初始化顺序。对于必须在编译期执行的函数（如元编程、查找表生成），使用 `consteval` 而非 `constexpr`。"

反面示例：

cpp 复制代码

// ❌ 静态初始化顺序问题（SIOF）
const std::string& getConfig() {
    static std::string config = loadFromFile(); // 运行时初始化，顺序不确定
    return config;
}

正面示例：

cpp 复制代码

// ✅ 编译期初始化，安全
constinit static std::array<int, 100> precomputedTable = computeTable();

// ✅ 必须在编译期求值
consteval int square(int n) {
    return n * n;
}
constexpr int value = square(10); // 编译期计算

规则 11：使用 `std::format` 代替字符串流或 `printf` 系列函数

原理： `std::format`（C++20）提供了类型安全、高性能、本地化友好的字符串格式化，语法类似 Python 的 `str.format`，比 `std::stringstream` 更高效，比 `printf` 更安全。

给模型的指令： "进行字符串格式化时，必须使用 `std::format`。禁止使用 `std::stringstream` 进行简单拼接，也禁止使用不安全的 `sprintf` 或 `printf` 系列函数。"

反面示例：

cpp 复制代码

// ❌ 冗长或类型不安全
std::stringstream ss;
ss << "Value: " << value << ", Name: " << name;
std::string result = ss.str();

// 或更危险的
char buffer[100];
sprintf(buffer, "Value: %d", value); // 可能缓冲区溢出

C++ 用 13 条规则让模型写出安全现代 C++

为什么需要规则？

规则 1：优先使用智能指针，禁止裸 `new`/`delete`

规则 2：使用 `const` 和 `constexpr` 最大化不变性

规则 3：使用范围 `for` 循环 (`for (auto&& item : range)`)

规则 4：使用 `std::string_view` 代替 `const std::string&` 或 `const char*` 作为只读字符串参数

规则 5：使用 `std::optional` 明确表示"可能有值"

规则 6：使用 `std::variant` 代替裸联合体或继承层次

规则 7：使用 `\[nodiscard]` 属性标记不应忽略返回值的函数

规则 8：使用结构化绑定 (`auto a, b = ...`)

规则 9：使用 `std::span` 作为连续序列的视图参数

规则 10：使用 `constinit` 和 `consteval` 强化编译期行为 (C++20)

规则 11：使用 `std::format` 代替字符串流或 `printf` 系列函数

规则 7：使用 ` $\[nodiscard$ ]` 属性标记不应忽略返回值的函数

规则 8：使用结构化绑定 (`auto $a, b$ = ...`)