特殊成员函数
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
- 声明析构函数会抑制移动操作生成——这是最容易踩的性能陷阱