C++ 惯用法与最佳实践 on Dorkytiger 的小屋

PIMPL 惯用法（Pointer to Implementation）

Mon, 01 Jan 0001 00:00:00 +0000

一、解决什么问题？

问题：你有一个类的头文件，暴露了私有成员。每次修改私有成员，所有包含这个头文件的 .cpp 都要重新编译——大项目里一次改动触发 10 分钟的全量编译。

// widget.h — ❌ 私有成员在头文件里
class Widget {
    std::string title_;       // private
    std::vector<int> data_;   // private
    // 每次改这些私有成员，所有 include widget.h 的 .cpp 都要重编
public:
    void show();
};

PIMPL 的做法：私有成员放到一个 Impl 结构体，只在前向声明：

// widget.h
class Widget {
    struct Impl;               // 只声明，不定义
    std::unique_ptr<Impl> pimpl_;

public:
    Widget();
    ~Widget();                 // 析构必须在 .cpp 中定义（因为 Impl 是不完整类型）
    void show();
};

// widget.cpp
struct Widget::Impl {
    std::string title_;
    std::vector<int> data_;
};

Widget::Widget() : pimpl_(std::make_unique<Impl>()) {}
Widget::~Widget() = default;  // 必须在这里定义

void Widget::show() {
    // 通过 pimpl_ 访问私有成员
    std::cout << pimpl_->title_;
}

效果：改 Impl 的成员只需要编译 widget.cpp，不需要重新编译所有 #include "widget.h" 的文件。

NVI（非虚接口模式）

Mon, 01 Jan 0001 00:00:00 +0000

一、NVI 的核心思想

非虚接口（Non-Virtual Interface）：基类的公有接口不是虚函数，而是调用私有的虚函数。

class DataProcessor {
public:
    // 公有接口——非虚
    void process() {
        // 统一的前置处理
        std::lock_guard<std::mutex> lock(mtx_);
        log_start();

        // 调用派生类实现的虚函数
        do_process();

        // 统一的后置处理
        log_end();
    }

    virtual ~DataProcessor() = default;

private:
    std::mutex mtx_;

    // 私有虚函数——派生类改写这个
    virtual void do_process() = 0;

    void log_start() { /* ... */ }
    void log_end()   { /* ... */ }
};

好处：基类在 process() 中统一添加了日志、锁、性能统计，派生类只需要关心 do_process() 的业务逻辑，不需要重复写这些横切关注点。

Copy-and-Swap 惯用法

Mon, 01 Jan 0001 00:00:00 +0000

一、异常安全的赋值运算符

class Buffer {
    int* data_;
    size_t size_;

public:
    // 拷贝构造
    Buffer(const Buffer& other) : size_(other.size_) {
        data_ = new int[size_];
        std::copy(other.data_, other.data_ + size_, data_);
    }

    // 析构
    ~Buffer() { delete[] data_; }

    // 赋值运算符——Copy-and-Swap 写法
    Buffer& operator=(Buffer other) {  // 传值：拷贝构造或移动构造
        swap(other);
        return *this;
    }

    // 交换
    void swap(Buffer& other) noexcept {
        std::swap(data_, other.data_);
        std::swap(size_, other.size_);
    }
};

为什么这种写法是异常安全的？

传统写法：

Buffer& operator=(const Buffer& other) {
    delete[] data_;              // 先释放旧资源
    data_ = new int[other.size_]; // 如果这里 new 抛异常 → data_ 悬垂！💥
    size_ = other.size_;
    std::copy(...);
    return *this;
}

Copy-and-Swap：先拷贝（可能抛异常，但原对象不受影响），如果拷贝成功，再交换指针。即使拷贝抛出异常，原对象不变。

`noexcept` 与移动语义

Mon, 01 Jan 0001 00:00:00 +0000

一、为什么移动构造函数要加 noexcept？

struct Widget {
    Widget(Widget&& other) noexcept { /* 移动资源 */ }
    Widget& operator=(Widget&& other) noexcept { /* ... */ }
};

原因：std::vector 扩容时，如果移动构造是 noexcept，它用移动搬移旧元素到新内存。如果不是 noexcept，它只能用拷贝（因为拷贝抛异常时旧数组还在，移动抛异常时旧数组已被破坏）。

std::vector<Widget> v;
v.push_back(Widget{});  // 可能触发扩容

// 如果 Widget 的移动构造是 noexcept：
//   → 把旧元素 move 到新内存（指针交换，快）
// 如果 Widget 的移动构造不是 noexcept：
//   → 把旧元素 copy 到新内存（深拷贝，慢）

`explicit` 与 `[[nodiscard]]`

Mon, 01 Jan 0001 00:00:00 +0000

一、`explicit`——防止隐式转换

struct StringWrapper {
    /* explicit */ StringWrapper(const char* s) { ... }
};

void process(StringWrapper sw);

// 如果没有 explicit：
process("hello");  // 隐式构造 StringWrapper → 可能不是你想要的！

// 如果有 explicit：
process("hello");  // ❌ 编译错误，必须显式构造
process(StringWrapper("hello"));  // ✅

规则：所有单参数构造函数都应该加 explicit，除非你真的想让隐式转换发生（极少见）。

二、`[[nodiscard]]`——返回值不要被忽略

struct Error { int code; };

class Config {
public:
    [[nodiscard]] Error load(const std::string& path) {
        // 如果加载失败，返回错误
        return Error{42};
    }
};

Config cfg;
cfg.load("config.ini");  // ⚠️ 编译器警告：返回值被忽略！

// 必须处理：
Error e = cfg.load("config.ini");  // ✅

哪些返回值应该加 [[nodiscard]]？

C++ 惯用法与最佳实践 on Dorkytiger 的小屋

PIMPL 惯用法（Pointer to Implementation）

一、解决什么问题？

NVI（非虚接口模式）

一、NVI 的核心思想

Copy-and-Swap 惯用法

一、异常安全的赋值运算符

`noexcept` 与移动语义

一、为什么移动构造函数要加 noexcept？

`explicit` 与 `[[nodiscard]]`

一、explicit——防止隐式转换

二、[[nodiscard]]——返回值不要被忽略

一、`explicit`——防止隐式转换

二、`[[nodiscard]]`——返回值不要被忽略