Cpp Coding Standards

C++ 编码标准（C++ 核心准则）

源自 C++ 核心准则 的现代 C++（C++17/20/23）综合编码标准。强制执行类型安全、资源安全、不变性和清晰性。

何时使用

• 编写新的 C++ 代码（类、函数、模板）
• 审查或重构现有的 C++ 代码
• 在 C++ 项目中做出架构决策
• 在 C++ 代码库中强制执行一致的风格
• 在语言特性之间做出选择（例如，enum 对比 enum class，原始指针对比智能指针）

何时不应使用

• 非 C++ 项目
• 无法采用现代 C++ 特性的遗留 C 代码库
• 特定准则与硬件限制冲突的嵌入式/裸机环境（选择性适配）

贯穿性原则

这些主题在整个准则中反复出现，并构成了基础：

1. 处处使用 RAII (P.8, R.1, E.6, CP.20)：将资源生命周期绑定到对象生命周期
2. 默认为不可变性 (P.10, Con.1-5, ES.25)：从 const/constexpr 开始；可变性是例外
3. 类型安全 (P.4, I.4, ES.46-49, Enum.3)：使用类型系统在编译时防止错误
4. 表达意图 (P.3, F.1, NL.1-2, T.10)：名称、类型和概念应传达目的
5. 最小化复杂性 (F.2-3, ES.5, Per.4-5)：简单的代码就是正确的代码
6. 值语义优于指针语义 (C.10, R.3-5, F.20, CP.31)：优先按值返回和作用域对象

哲学与接口 (P.*, I.*)

关键规则

应该做

cppCopy code
// P.10 + I.4: Immutable, strongly typed interface
struct Temperature {
    double kelvin;
};

Temperature boil(const Temperature& water);

不应该做

cppCopy code
// Weak interface: unclear ownership, unclear units
double boil(double* temp);

// Non-const global variable
int g_counter = 0;  // I.2 violation

函数 (F.*)

关键规则

参数传递

cppCopy code
// F.16: Cheap types by value, others by const&
void print(int x);                           // cheap: by value
void analyze(const std::string& data);       // expensive: by const&
void transform(std::string s);               // sink: by value (will move)

// F.20 + F.21: Return values, not output parameters
struct ParseResult {
    std::string token;
    int position;
};

ParseResult parse(std::string_view input);   // GOOD: return struct

// BAD: output parameters
void parse(std::string_view input,
           std::string& token, int& pos);    // avoid this

纯函数和 constexpr

cppCopy code
// F.4 + F.8: Pure, constexpr where possible
constexpr int factorial(int n) noexcept {
    return (n <= 1) ? 1 : n * factorial(n - 1);
}

static_assert(factorial(5) == 120);

反模式

• 从函数返回 T&& (F.45)
• 使用 va_arg / C 风格可变参数 (F.55)
• 在传递给其他线程的 lambda 中通过引用捕获 (F.53)
• 返回 const T，这会抑制移动语义 (F.49)

类与类层次结构 (C.*)

关键规则

零规则

cppCopy code
// C.20: Let the compiler generate special members
struct Employee {
    std::string name;
    std::string department;
    int id;
    // No destructor, copy/move constructors, or assignment operators needed
};

五规则

cppCopy code
// C.21: If you must manage a resource, define all five
class Buffer {
public:
    explicit Buffer(std::size_t size)
        : data_(std::make_unique<char[]>(size)), size_(size) {}

    ~Buffer() = default;

    Buffer(const Buffer& other)
        : data_(std::make_unique<char[]>(other.size_)), size_(other.size_) {
        std::copy_n(other.data_.get(), size_, data_.get());
    }

    Buffer& operator=(const Buffer& other) {
        if (this != &other) {
            auto new_data = std::make_unique<char[]>(other.size_);
            std::copy_n(other.data_.get(), other.size_, new_data.get());
            data_ = std::move(new_data);
            size_ = other.size_;
        }
        return *this;
    }

    Buffer(Buffer&&) noexcept = default;
    Buffer& operator=(Buffer&&) noexcept = default;

private:
    std::unique_ptr<char[]> data_;
    std::size_t size_;
};

类层次结构

cppCopy code
// C.35 + C.128: Virtual destructor, use override
class Shape {
public:
    virtual ~Shape() = default;
    virtual double area() const = 0;  // C.121: pure interface
};

class Circle : public Shape {
public:
    explicit Circle(double r) : radius_(r) {}
    double area() const override { return 3.14159 * radius_ * radius_; }

private:
    double radius_;
};

反模式

• 在构造函数/析构函数中调用虚函数 (C.82)
• 在非平凡类型上使用 memset/memcpy (C.90)
• 为虚函数和重写函数提供不同的默认参数 (C.140)
• 将数据成员设为 const 或引用，这会抑制移动/拷贝 (C.12)

资源管理 (R.*)

关键规则

智能指针使用

cppCopy code
// R.11 + R.20 + R.21: RAII with smart pointers
auto widget = std::make_unique<Widget>("config");  // unique ownership
auto cache  = std::make_shared<Cache>(1024);        // shared ownership

// R.3: Raw pointer = non-owning observer
void render(const Widget* w) {  // does NOT own w
    if (w) w->draw();
}

render(widget.get());

RAII 模式

cppCopy code
// R.1: Resource acquisition is initialization
class FileHandle {
public:
    explicit FileHandle(const std::string& path)
        : handle_(std::fopen(path.c_str(), "r")) {
        if (!handle_) throw std::runtime_error("Failed to open: " + path);
    }

    ~FileHandle() {
        if (handle_) std::fclose(handle_);
    }

    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
    FileHandle(FileHandle&& other) noexcept
        : handle_(std::exchange(other.handle_, nullptr)) {}
    FileHandle& operator=(FileHandle&& other) noexcept {
        if (this != &other) {
            if (handle_) std::fclose(handle_);
            handle_ = std::exchange(other.handle_, nullptr);
        }
        return *this;
    }

private:
    std::FILE* handle_;
};

反模式

• 裸 new/delete (R.11)
• C++ 代码中的 malloc()/free() (R.10)
• 在单个表达式中进行多次资源分配 (R.13 -- 异常安全风险)
• 在 unique_ptr 足够时使用 shared_ptr (R.21)

表达式与语句 (ES.*)

关键规则

初始化

cppCopy code
// ES.20 + ES.23 + ES.25: Always initialize, prefer {}, default to const
const int max_retries{3};
const std::string name{"widget"};
const std::vector<int> primes{2, 3, 5, 7, 11};

// ES.28: Lambda for complex const initialization
const auto config = [&] {
    Config c;
    c.timeout = std::chrono::seconds{30};
    c.retries = max_retries;
    c.verbose = debug_mode;
    return c;
}();

反模式

• 未初始化的变量 (ES.20)
• 使用 0 或 NULL 作为指针 (ES.47 -- 使用 nullptr)
• C 风格强制类型转换 (ES.48 -- 使用 static_cast、const_cast 等)
• 丢弃 const (ES.50)
• 没有命名常量的魔法数字 (ES.45)
• 混合有符号和无符号算术 (ES.100)
• 在嵌套作用域中重用名称 (ES.12)

错误处理 (E.*)

关键规则

异常层次结构

cppCopy code
// E.14 + E.15: Custom exception types, throw by value, catch by reference
class AppError : public std::runtime_error {
public:
    using std::runtime_error::runtime_error;
};

class NetworkError : public AppError {
public:
    NetworkError(const std::string& msg, int code)
        : AppError(msg), status_code(code) {}
    int status_code;
};

void fetch_data(const std::string& url) {
    // E.2: Throw to signal failure
    throw NetworkError("connection refused", 503);
}

void run() {
    try {
        fetch_data("https://api.example.com");
    } catch (const NetworkError& e) {
        log_error(e.what(), e.status_code);
    } catch (const AppError& e) {
        log_error(e.what());
    }
    // E.17: Don't catch everything here -- let unexpected errors propagate
}

反模式

• 抛出内置类型，如 int 或字符串字面量 (E.14)
• 按值捕获（有切片风险） (E.15)
• 静默吞掉错误的空 catch 块
• 使用异常进行流程控制 (E.3)
• 基于全局状态（如 errno）的错误处理 (E.28)

常量与不可变性 (Con.*)

所有规则

cppCopy code
// Con.1 through Con.5: Immutability by default
class Sensor {
public:
    explicit Sensor(std::string id) : id_(std::move(id)) {}

    // Con.2: const member functions by default
    const std::string& id() const { return id_; }
    double last_reading() const { return reading_; }

    // Only non-const when mutation is required
    void record(double value) { reading_ = value; }

private:
    const std::string id_;  // Con.4: never changes after construction
    double reading_{0.0};
};

// Con.3: Pass by const reference
void display(const Sensor& s) {
    std::cout << s.id() << ": " << s.last_reading() << '\n';
}

// Con.5: Compile-time constants
constexpr double PI = 3.14159265358979;
constexpr int MAX_SENSORS = 256;

并发与并行 (CP.*)

关键规则

安全加锁

cppCopy code
// CP.20 + CP.44: RAII locks, always named
class ThreadSafeQueue {
public:
    void push(int value) {
        std::lock_guard<std::mutex> lock(mutex_);  // CP.44: named!
        queue_.push(value);
        cv_.notify_one();
    }

    int pop() {
        std::unique_lock<std::mutex> lock(mutex_);
        // CP.42: Always wait with a condition
        cv_.wait(lock, [this] { return !queue_.empty(); });
        const int value = queue_.front();
        queue_.pop();
        return value;
    }

private:
    std::mutex mutex_;             // CP.50: mutex with its data
    std::condition_variable cv_;
    std::queue<int> queue_;
};

多个互斥量

cppCopy code
// CP.21: std::scoped_lock for multiple mutexes (deadlock-free)
void transfer(Account& from, Account& to, double amount) {
    std::scoped_lock lock(from.mutex_, to.mutex_);
    from.balance_ -= amount;
    to.balance_ += amount;
}

反模式

• 使用 volatile 进行同步 (CP.8 -- 它仅用于硬件 I/O)
• 分离线程 (CP.26 -- 生命周期管理变得几乎不可能)
• 未命名的锁保护：std::lock_guard<std::mutex>(m); 会立即销毁 (CP.44)
• 调用回调时持有锁 (CP.22 -- 死锁风险)
• 没有深厚专业知识就进行无锁编程 (CP.100)

模板与泛型编程 (T.*)

关键规则

概念 (C++20)

cppCopy code
#include <concepts>

// T.10 + T.11: Constrain templates with standard concepts
template<std::integral T>
T gcd(T a, T b) {
    while (b != 0) {
        a = std::exchange(b, a % b);
    }
    return a;
}

// T.13: Shorthand concept syntax
void sort(std::ranges::random_access_range auto& range) {
    std::ranges::sort(range);
}

// Custom concept for domain-specific constraints
template<typename T>
concept Serializable = requires(const T& t) {
    { t.serialize() } -> std::convertible_to<std::string>;
};

template<Serializable T>
void save(const T& obj, const std::string& path);

反模式

• 在可见命名空间中使用无约束模板 (T.47)
• 特化函数模板而非重载 (T.144)
• 在 constexpr 足够时使用模板元编程 (T.120)
• 使用 typedef 而非 using (T.43)

标准库 (SL.*)

关键规则

cppCopy code
// SL.con.1 + SL.con.2: Prefer vector/array over C arrays
const std::array<int, 4> fixed_data{1, 2, 3, 4};
std::vector<std::string> dynamic_data;

// SL.str.1 + SL.str.2: string owns, string_view observes
std::string build_greeting(std::string_view name) {
    return "Hello, " + std::string(name) + "!";
}

// SL.io.50: Use '\n' not endl
std::cout << "result: " << value << '\n';

枚举 (Enum.*)

关键规则

cppCopy code
// Enum.3 + Enum.5: Scoped enum, no ALL_CAPS
enum class Color { red, green, blue };
enum class LogLevel { debug, info, warning, error };

// BAD: plain enum leaks names, ALL_CAPS clashes with macros
enum { RED, GREEN, BLUE };           // Enum.3 + Enum.5 + Enum.6 violation
#define MAX_SIZE 100                  // Enum.1 violation -- use constexpr

源文件与命名 (SF., NL.)

关键规则

头文件防护

cppCopy code
// SF.8: Include guard (or #pragma once)
#ifndef PROJECT_MODULE_WIDGET_H
#define PROJECT_MODULE_WIDGET_H

// SF.11: Self-contained -- include everything this header needs
#include <string>
#include <vector>

namespace project::module {

class Widget {
public:
    explicit Widget(std::string name);
    const std::string& name() const;

private:
    std::string name_;
};

}  // namespace project::module

#endif  // PROJECT_MODULE_WIDGET_H

命名约定

cppCopy code
// NL.8 + NL.10: Consistent underscore_style
namespace my_project {

constexpr int max_buffer_size = 4096;  // NL.9: not ALL_CAPS (it's not a macro)

class tcp_connection {                 // underscore_style class
public:
    void send_message(std::string_view msg);
    bool is_connected() const;

private:
    std::string host_;                 // trailing underscore for members
    int port_;
};

}  // namespace my_project

反模式

• 在头文件的全局作用域内使用 using namespace std; (SF.7)
• 依赖包含顺序的头文件 (SF.10, SF.11)
• 匈牙利命名法，如 strName、iCount (NL.5)
• 宏以外的事物使用 ALL_CAPS (NL.9)

性能 (Per.*)

关键规则

指导原则

cppCopy code
// Per.11: Compile-time computation where possible
constexpr auto lookup_table = [] {
    std::array<int, 256> table{};
    for (int i = 0; i < 256; ++i) {
        table[i] = i * i;
    }
    return table;
}();

// Per.19: Prefer contiguous data for cache-friendliness
std::vector<Point> points;           // GOOD: contiguous
std::vector<std::unique_ptr<Point>> indirect_points; // BAD: pointer chasing

反模式

• 在没有性能分析数据的情况下进行优化 (Per.1, Per.6)
• 选择“巧妙”的低级代码而非清晰的抽象 (Per.4, Per.5)
• 忽略数据布局和缓存行为 (Per.19)

快速参考检查清单

在标记 C++ 工作完成之前：

• [ ] 没有裸 new/delete —— 使用智能指针或 RAII (R.11)
• [ ] 对象在声明时初始化 (ES.20)
• [ ] 变量默认是 const/constexpr (Con.1, ES.25)
• [ ] 成员函数尽可能设为 const (Con.2)
• [ ] 使用 enum class 而非普通 enum (Enum.3)
• [ ] 使用 nullptr 而非 0/NULL (ES.47)
• [ ] 没有窄化转换 (ES.46)
• [ ] 没有 C 风格转换 (ES.48)
• [ ] 单参数构造函数是 explicit (C.46)
• [ ] 应用了零法则或五法则 (C.20, C.21)
• [ ] 基类析构函数是 public virtual 或 protected non-virtual (C.35)
• [ ] 模板使用概念进行约束 (T.10)
• [ ] 头文件全局作用域内没有 using namespace (SF.7)
• [ ] 头文件有包含防护且是自包含的 (SF.8, SF.11)
• [ ] 锁使用 RAII (scoped_lock/lock_guard) (CP.20)
• [ ] 异常是自定义类型，按值抛出，按引用捕获 (E.14, E.15)
• [ ] 使用 '\n' 而非 std::endl (SL.io.50)
• [ ] 没有魔数 (ES.45)