特殊成员函数

C++ 编译器可以为类自动生成多达六个特殊成员函数(Special Member Functions)。理解它们的声明方式、自动生成条件和相互抑制关系,是编写安全、高效类的基础。本节将系统讲解这六个函数,并给出现代 C++ 中"零法则"与"五法则"的工程决策方法。

六个特殊成员函数

编译器可以自动生成以下六个特殊成员函数。如果你不声明它们,编译器会在满足条件时隐式提供默认版本:

class Widget {
public:
    // 1. 默认构造函数 (Default Constructor)
    Widget();

    // 2. 析构函数 (Destructor)
    ~Widget();

    // 3. 拷贝构造函数 (Copy Constructor)
    Widget(const Widget& other);

    // 4. 拷贝赋值运算符 (Copy Assignment Operator)
    Widget& operator=(const Widget& other);

    // 5. 移动构造函数 (Move Constructor)
    Widget(Widget&& other) noexcept;

    // 6. 移动赋值运算符 (Move Assignment Operator)
    Widget& operator=(Widget&& other) noexcept;
};

记忆口诀:默认构造 + 析构 + 拷贝两件套 + 移动两件套 = 1 + 1 + 2 + 2 = 6。移动操作应当声明为 noexcept,这是标准容器高效使用移动语义的前提条件。

每个函数的职责非常明确:

  • 默认构造:无参数创建对象,将每个成员默认初始化
  • 析构:对象生命周期结束时调用,负责释放资源
  • 拷贝构造:从同类型对象创建一份独立副本
  • 拷贝赋值:将已有对象的状态重置为另一对象的副本
  • 移动构造:从即将销毁的对象"窃取"资源,避免深拷贝
  • 移动赋值:同上,但目标对象已存在,需先释放旧资源

Rule of Zero(零法则)——首选!

现代 C++ 的核心理念:如果类的所有成员都能自我管理资源,就不要声明任何特殊成员函数。编译器生成的默认版本会逐成员调用对应操作,完全正确。

#include <string>
#include <vector>
#include <memory>

// 零法则范例 —— 不声明任何特殊成员函数
struct Employee {
    std::string              name;
    int                      age{};
    std::vector<std::string> skills;
    std::unique_ptr<Project> current_project;  // 独占所有权

    // 编译器自动生成:
    // - 默认构造:每个成员默认初始化
    // - 析构:逐成员销毁(unique_ptr 自动 delete)
    // - 移动构造/赋值:逐成员移动(unique_ptr 可移动)
    // - 拷贝:因为 unique_ptr 不可拷贝 → 拷贝操作被隐式 delete
};

int main() {
    Employee alice{"Alice", 30, {"C++", "Python"}, nullptr};

    // 移动 OK
    Employee bob = std::move(alice);

    // 拷贝 —— 编译错误!unique_ptr 不可拷贝
    // Employee clone = bob;

    return 0;
}

零法则是默认目标。当你想为类编写析构函数或拷贝/移动操作时,先问自己:"能否用智能指针或 RAII 包装器让成员自管理?"如果能,就不需要手写任何特殊成员。

零法则的好处:

  • 代码更短,维护成本低
  • 不会因遗漏某个操作导致 bug
  • 添加新成员时无需修改任何特殊成员函数
  • 编译器生成的移动操作是 noexcept 的(当所有成员的移动都是 noexcept)

Rule of Five(五法则)

如果你必须自定义析构函数、拷贝构造或拷贝赋值中的任何一个,那就必须显式声明全部五个(析构 + 拷贝两件套 + 移动两件套)。原因:声明其中一个会抑制编译器自动生成移动操作。

// 管理裸资源的类 —— 必须遵循五法则
class Buffer {
    size_t  size_;
    double* data_;   // 裸指针 → 手动管理

public:
    // 构造
    explicit Buffer(size_t n)
        : size_{n}, data_{new double[n]{}} {}

    // 1. 析构函数
    ~Buffer() {
        delete[] data_;
    }

    // 2. 拷贝构造 —— 深拷贝
    Buffer(const Buffer& other)
        : size_{other.size_}, data_{new double[other.size_]} {
        std::copy_n(other.data_, size_, data_);
    }

    // 3. 拷贝赋值 —— copy-and-swap 惯用法
    Buffer& operator=(const Buffer& other) {
        if (this != &other) {
            Buffer tmp{other};        // 拷贝构造临时对象
            swap(*this, tmp);         // 交换资源
        }                             // tmp 析构释放旧资源
        return *this;
    }

    // 4. 移动构造 —— 窃取资源
    Buffer(Buffer&& other) noexcept
        : size_{other.size_}, data_{other.data_} {
        other.size_ = 0;
        other.data_ = nullptr;       // 让源对象处于可析构状态
    }

    // 5. 移动赋值
    Buffer& operator=(Buffer&& other) noexcept {
        if (this != &other) {
            delete[] data_;          // 释放当前资源
            size_ = other.size_;
            data_ = other.data_;
            other.size_ = 0;
            other.data_ = nullptr;
        }
        return *this;
    }

    // swap 辅助
    friend void swap(Buffer& a, Buffer& b) noexcept {
        std::swap(a.size_, b.size_);
        std::swap(a.data_, b.data_);
    }

    // 访问
    size_t size() const { return size_; }
    double& operator[](size_t i) { return data_[i]; }
    const double& operator[](size_t i) const { return data_[i]; }
};

忘记移动操作的后果:如果你只定义了析构和拷贝(C++03 风格的"三法则"),那么编译器不会生成移动操作。所有本应被移动的场景都会退化为拷贝,性能严重下降,而且你不会得到任何编译警告!

= default —— 显式请求默认实现

= default 告诉编译器:"请为我生成这个函数的默认版本。" 它既是代码意图的文档,也避免了手写实现可能带来的错误。

class Base {
public:
    // 让析构函数为 virtual,同时保持默认实现
    virtual ~Base() = default;

    // 显式声明析构后,移动操作不再自动生成
    // 用 = default 恢复它们
    Base(Base&&) noexcept = default;
    Base& operator=(Base&&) noexcept = default;

    // 拷贝也显式 = default(此时编译器已不会隐式生成)
    Base(const Base&) = default;
    Base& operator=(const Base&) = default;
};

// 常见用法:让结构体可以聚合初始化,同时保留默认构造
struct Config {
    int    width  = 800;
    int    height = 600;
    bool   vsync  = true;

    Config() = default;  // 保留默认构造
    // 仍然支持 Config{1920, 1080, false} 聚合初始化 (C++20)
};

= default 的典型应用场景:

  • 基类需要 virtual ~Base() = default; 以支持多态删除
  • 声明了一个特殊成员后,用 = default 恢复被抑制的其他成员
  • 让意图显式化——"我确实考虑过这些操作,使用默认版本是经过深思熟虑的"

= delete —— 禁止操作

= delete 明确禁止某个函数的使用。尝试调用被删除的函数会导致编译错误,且错误信息清晰。

// 用例 1:不可拷贝类型(独占资源)
class UniqueConnection {
    int fd_;
public:
    explicit UniqueConnection(const char* addr);
    ~UniqueConnection();

    // 禁止拷贝
    UniqueConnection(const UniqueConnection&) = delete;
    UniqueConnection& operator=(const UniqueConnection&) = delete;

    // 允许移动
    UniqueConnection(UniqueConnection&&) noexcept;
    UniqueConnection& operator=(UniqueConnection&&) noexcept;
};

// 用例 2:防止隐式类型转换
class Pixel {
    uint8_t r_, g_, b_;
public:
    Pixel(uint8_t r, uint8_t g, uint8_t b) : r_{r}, g_{g}, b_{b} {}

    // 禁止从 int/double 等隐式转换
    Pixel(int) = delete;
    Pixel(double) = delete;
};

// 用例 3:禁止在堆上创建
class StackOnly {
    int value_;
public:
    StackOnly(int v) : value_{v} {}
    void* operator new(size_t) = delete;      // 禁止 new
    void* operator new[](size_t) = delete;    // 禁止 new[]
};

C++23: = delete("原因")

C++23 允许在 = delete 后附带一个字符串字面量,说明删除原因。编译器会在错误信息中显示这段文字:

class ThreadPool {
public:
    // C++23: 删除时附带原因说明
    ThreadPool(const ThreadPool&) = delete("ThreadPool 拥有工作线程,不可拷贝");
    ThreadPool& operator=(const ThreadPool&) = delete("使用 shared_ptr<ThreadPool> 共享");

    // 防止误用
    void submit(std::nullptr_t) = delete("不能提交空任务,请传入可调用对象");
    void submit(std::function<void()> task);
};

= delete("reason") 需要 C++23 支持(GCC 13+, Clang 17+, MSVC 19.37+)。在此之前可以通过注释达到类似效果,但编译错误不会自动显示注释内容。

Deducing this(C++23 显式对象参数)

C++23 引入了显式对象参数(explicit object parameter),使用 this 关键字声明。这从根本上解决了 const/非 const 重载重复代码的问题,并开启了全新的设计模式。

消除 const/非 const 重载重复

// C++20 之前:两个几乎相同的重载
class TextBuffer {
    std::string content_;
public:
    // 非 const 版本
    std::string& data() { return content_; }
    // const 版本
    const std::string& data() const { return content_; }
};

// C++23:一个模板函数搞定
class TextBuffer {
    std::string content_;
public:
    // Self 推导为 TextBuffer&, const TextBuffer&, TextBuffer&& 等
    template<typename Self>
    auto&& data(this Self&& self) {
        return std::forward<Self>(self).content_;
    }
};

无继承的 CRTP

// 传统 CRTP 需要继承
// template<typename Derived>
// class Addable { ... };
// class Vec2 : public Addable<Vec2> { ... };

// C++23: mixin 直接通过 deducing this
struct Addable {
    template<typename Self>
    auto operator+(this Self const& self, Self const& other) {
        auto result = self;
        result += other;  // 要求 Self 有 operator+=
        return result;
    }
};

struct Vec2 : Addable {
    double x{}, y{};
    Vec2& operator+=(const Vec2& o) { x += o.x; y += o.y; return *this; }
};

递归 Lambda

// C++23: lambda 通过 deducing this 实现递归
auto fibonacci = [](this auto const& self, int n) -> int {
    if (n <= 1) return n;
    return self(n - 1) + self(n - 2);
};

int result = fibonacci(10);  // 55

// 实用例子:递归遍历 variant 树
using Tree = std::variant<int, std::vector<Tree>>;

auto sum = [](this auto const& self, const Tree& tree) -> int {
    return std::visit([&](auto const& node) -> int {
        if constexpr (std::is_same_v<std::decay_t<decltype(node)>, int>) {
            return node;
        } else {
            int total = 0;
            for (auto const& child : node) total += self(child);
            return total;
        }
    }, tree);
};

Deducing this 需要 C++23 支持(GCC 14+, Clang 18+, MSVC 19.38+)。它不仅是语法糖——在设计链式 API、Builder 模式、Visitor 模式时都能大幅减少样板代码。

编译器生成规则

下表总结了用户声明一个特殊成员函数时,编译器对其他成员的生成行为:

用户声明了 ↓ 默认构造 析构 拷贝构造 拷贝赋值 移动构造 移动赋值
无(全部默认) 生成 生成 生成 生成 生成 生成
任何构造函数 不生成 生成 生成 生成 生成 生成
析构函数 生成 — 生成* 生成* 不生成 不生成
拷贝构造 不生成 生成 — 生成* 不生成 不生成
拷贝赋值 生成 生成 生成* — 不生成 不生成
移动构造 不生成 生成 = delete = delete — 不生成
移动赋值 生成 生成 = delete = delete 不生成 —

* 标记"生成*"表示该行为是 deprecated(已弃用)——标准仍然生成,但被视为遗留兼容行为,未来版本可能移除。不要依赖它!

隐式移动抑制陷阱:最常见的错误是声明了 virtual ~Base() = default; 后忘记恢复移动操作。此时所有 std::move 都静默退化为拷贝,没有编译警告,只有性能悬崖。开启 -Wdeprecated(GCC/Clang)可以捕获此类问题。

决策流程图

/*
  你的类管理裸资源吗?(裸指针、文件句柄、锁……)
      │
      ├─ 否 → 所有成员都是自管理类型?
      │        │
      │        ├─ 是 → [正确] Rule of Zero:不声明任何特殊成员
      │        │
      │        └─ 否 → 用 unique_ptr/shared_ptr 包装,回到 Zero
      │
      └─ 是 → [注意] Rule of Five:声明全部 5 个
               │
               ├─ 析构:释放资源
               ├─ 拷贝构造:深拷贝资源
               ├─ 拷贝赋值:copy-and-swap
               ├─ 移动构造:窃取资源 + noexcept
               └─ 移动赋值:释放旧资源 + 窃取新资源 + noexcept
*/

本章小结

  • C++ 有 6 个特殊成员函数:默认构造、析构、拷贝构造/赋值、移动构造/赋值
  • 零法则:优先使用自管理成员(string, vector, unique_ptr),让编译器处理所有操作
  • 五法则:管理裸资源时,必须同时定义析构 + 拷贝两件套 + 移动两件套
  • = default 恢复被抑制的默认实现,= delete 显式禁止操作
  • C++23 = delete("reason") 让错误信息更友好
  • C++23 deducing this 消除 const/非 const 重复、支持递归 lambda、无继承 CRTP
  • 声明析构函数会抑制移动操作生成——这是最容易踩的性能陷阱