RAII 与拷贝控制
用 RAII 管理资源并掌握拷贝与移动语义
#RAII:C++ 最重要的设计思想
RAII(Resource Acquisition Is Initialization,资源获取即初始化)是 C++ 区别于其他语言的核心哲学。它的表述很简单:把资源的生命周期绑定到一个栈对象的生命周期上——构造函数里获取资源,析构函数里释放资源。因为栈对象的析构时机是确定的(离开作用域必然执行),资源释放也就变得确定且自动。
在其他语言里你一定见过对应的补丁:Python 的 with open(...) as f:、Java 的 try (var f = ...)、C# 的 using。它们都是为了解决"忘记关闭文件"而发明的语法糖;而 C++ 的 RAII 不是语法糖,它是语言机制本身——任何类的析构函数都会在对象生命周期结束时被自动调用,你只要把清理逻辑写进析构函数,就不存在"忘记"这回事。
更关键的是 RAII 在异常发生时依然有效。C++ 保证栈展开(stack unwinding)过程中所有已构造的局部对象都会被析构,这让"异常安全"几乎免费。Java 的 finally 也能做,但要手写;Python 的 with 同理。
#include <cstdio>
#include <iostream>
#include <stdexcept>
#include <string>
// 一个 RAII 文件句柄:构造时打开,析构时关闭
class FileGuard {
public:
explicit FileGuard(const std::string& path, const char* mode) {
handle_ = std::fopen(path.c_str(), mode);
if (handle_ == nullptr) {
throw std::runtime_error("无法打开文件: " + path);
}
std::cout << "打开文件 " << path << "\n";
}
// 析构函数自动关闭,调用方不需要(也不能)手动 close
~FileGuard() {
if (handle_ != nullptr) {
std::fclose(handle_);
std::cout << "关闭文件\n";
}
}
// 禁止拷贝:文件句柄被复制会导致双重关闭
FileGuard(const FileGuard&) = delete;
FileGuard& operator=(const FileGuard&) = delete;
// 允许移动:所有权可以转移
FileGuard(FileGuard&& other) noexcept : handle_(other.handle_) {
other.handle_ = nullptr; // 源对象放弃所有权
}
FileGuard& operator=(FileGuard&& other) noexcept {
if (this != &other) {
if (handle_ != nullptr) {
std::fclose(handle_);
}
handle_ = other.handle_;
other.handle_ = nullptr;
}
return *this;
}
void write(const std::string& text) {
std::fwrite(text.data(), 1, text.size(), handle_);
}
private:
std::FILE* handle_{nullptr};
};
void risky_work() {
FileGuard f("demo.txt", "w"); // 构造即打开
f.write("第一行\n");
throw std::runtime_error("中途出错了");
// 即使抛异常,f 的析构函数依然会被调用,文件被正确关闭
}
int main() {
try {
risky_work();
} catch (const std::exception& e) {
std::cout << "捕获异常: " << e.what() << "\n";
}
{
FileGuard g("demo2.txt", "w");
g.write("正常结束\n");
} // 离开作用域,自动关闭
return 0;
}把 RAII 记牢:它是理解智能指针(unique_ptr/shared_ptr)、Qt 的父子对象树、以及后续所有 Qt 资源管理的前提。
#拷贝的陷阱与 Rule of Three
先看问题。当一个类持有裸指针(或文件描述符、socket 等资源)时,编译器自动生成的拷贝构造函数只会逐字节复制指针值,这叫浅拷贝。结果是两个对象指向同一块内存,析构时会被 delete 两次——这就是经典的 double free,程序随机崩溃。
对比一下其他语言:Python 里 b = a 是让两个名字引用同一个对象,语言层面就没有"值拷贝"这回事(要拷贝得写 copy.deepcopy);JS 同理;Java 的对象赋值也是共享引用。而 C++ 里 MyClass b = a; 默认就是值拷贝,会真的复制一份对象——这个"默认行为"正是 C++ 与它们最根本的分野。
Rule of Three 说的是:如果你需要手动定义析构函数、拷贝构造函数、拷贝赋值运算符中的任何一个,那么你几乎肯定需要三个都定义(C++11 后扩展为 Rule of Five,加上移动构造和移动赋值)。
#include <cstring>
#include <iostream>
// 反面教材:只有析构函数,没有处理拷贝
class BadString {
public:
explicit BadString(const char* s) {
size_ = std::strlen(s);
data_ = new char[size_ + 1];
std::memcpy(data_, s, size_ + 1);
}
~BadString() {
delete[] data_; // 浅拷贝会导致这里被执行两次 → 崩溃
}
const char* c_str() const { return data_; }
private:
char* data_;
std::size_t size_;
};
// 正面教材:Rule of Three 三件套齐全
class MyString {
public:
explicit MyString(const char* s = "") {
size_ = std::strlen(s);
data_ = new char[size_ + 1];
std::memcpy(data_, s, size_ + 1);
std::cout << "构造 " << data_ << "\n";
}
// 1) 析构函数
~MyString() {
std::cout << "析构 " << (data_ ? data_ : "(空)") << "\n";
delete[] data_;
}
// 2) 拷贝构造:深拷贝,分配自己的内存
MyString(const MyString& other) : size_(other.size_) {
data_ = new char[size_ + 1];
std::memcpy(data_, other.data_, size_ + 1);
std::cout << "拷贝构造 " << data_ << "\n";
}
// 3) 拷贝赋值:先处理自赋值,再释放旧资源,最后深拷贝
MyString& operator=(const MyString& other) {
std::cout << "拷贝赋值\n";
if (this == &other) {
return *this; // 自赋值保护,a = a 时必须先判
}
// 先分配新内存再释放旧的:即使 new 抛异常,对象仍保持原状
char* new_data = new char[other.size_ + 1];
std::memcpy(new_data, other.data_, other.size_ + 1);
delete[] data_;
data_ = new_data;
size_ = other.size_;
return *this;
}
std::size_t size() const { return size_; }
const char* c_str() const { return data_; }
private:
char* data_{nullptr};
std::size_t size_{0};
};
int main() {
MyString a("hello");
MyString b = a; // 拷贝构造:b 有自己的内存
MyString c("world");
c = a; // 拷贝赋值:c 释放旧内存后复制 a
std::cout << b.c_str() << " " << c.c_str() << "\n";
// 下面这段如果用 BadString 就会崩溃(double free)
// BadString x("hi");
// BadString y = x;
return 0;
}注意拷贝赋值里"先分配、后释放"的顺序:如果先 delete[] data_ 再 new,一旦 new 抛异常,对象就处于持有悬垂指针的损坏状态。这叫强异常安全保证,是专业 C++ 代码的基本要求。
#右值引用、移动语义与 std::move
深拷贝是安全的,但很多时候是浪费的:MyString b = make_huge_string(); 里的临时对象马上就要销毁,为它复制一份纯粹白费。C++11 引入移动语义解决这个问题:对于"即将消亡的对象"(右值),直接偷走它的资源,而不是复制。
先厘清术语:
- 左值(lvalue):有名字、有持久地址、可以取地址的表达式,如变量
a。 - 右值(rvalue):临时的、即将消亡的表达式,如字面量
42、函数返回的临时对象、a + b的结果。 - 右值引用
T&&:只能绑定到右值的引用类型。T&是左值引用。 std::move(x):它不移动任何东西,只是一个强制类型转换,把x转成右值引用,从而让重载决议选中移动版本。真正的移动发生在移动构造函数里。
Python 和 JS 里对象赋值天然就是"共享引用 + 引用计数",从不需要搬运;Java 也一样。所以移动语义是 C++ 独有的性能工具,也是你从这些语言转过来时最陌生的一节。
#include <cstring>
#include <iostream>
#include <utility> // std::move, std::swap
class Buffer {
public:
explicit Buffer(std::size_t n) : size_(n), data_(new int[n]{}) {
std::cout << "构造 size=" << size_ << "\n";
}
~Buffer() {
delete[] data_;
}
// 拷贝构造:真的复制数据,O(n)
Buffer(const Buffer& other) : size_(other.size_), data_(new int[other.size_]) {
std::memcpy(data_, other.data_, size_ * sizeof(int));
std::cout << "拷贝构造 size=" << size_ << "\n";
}
// 移动构造:只偷指针,O(1),必须标记 noexcept
// noexcept 很重要:std::vector 扩容时只有移动构造不抛异常才敢用移动
Buffer(Buffer&& other) noexcept
: size_(other.size_), data_(other.data_)
{
other.size_ = 0;
other.data_ = nullptr; // 源对象置空,保证析构时不会释放这块内存
std::cout << "移动构造 size=" << size_ << "\n";
}
// 拷贝赋值:用 copy-and-swap 惯用法,天然处理自赋值且异常安全
Buffer& operator=(const Buffer& other) {
std::cout << "拷贝赋值\n";
if (this != &other) {
Buffer tmp(other); // 先构造副本
swap(tmp); // 再交换
}
return *this; // tmp 析构,带走旧资源
}
// 移动赋值:释放自己的,接管对方的
Buffer& operator=(Buffer&& other) noexcept {
std::cout << "移动赋值\n";
if (this != &other) {
delete[] data_;
data_ = other.data_;
size_ = other.size_;
other.data_ = nullptr;
other.size_ = 0;
}
return *this;
}
void swap(Buffer& other) noexcept {
std::swap(size_, other.size_);
std::swap(data_, other.data_);
}
std::size_t size() const { return size_; }
private:
std::size_t size_{0};
int* data_{nullptr};
};
Buffer make_buffer(std::size_t n) {
return Buffer(n); // 返回临时对象,触发移动(或被 NRVO 直接优化掉)
}
int main() {
Buffer a(1000);
Buffer b = a; // 拷贝构造:左值,只能复制
Buffer c = make_buffer(2000); // 移动构造(或更优:编译器直接省略拷贝)
Buffer d(10);
d = std::move(a); // 移动赋值:明确表示"a 我不要了"
std::cout << "b=" << b.size()
<< " c=" << c.size()
<< " d=" << d.size()
<< " a=" << a.size() << "\n"; // a 被搬空,size 变 0
return 0;
}关于 std::move(a) 之后:a 仍然是一个有效但未指定状态的对象——你可以销毁它,也可以给它赋新值,但不要读取它的内容。这是 C++ 的约定:"被移动的对象只剩空壳"。
#Rule of Five 与 Rule of Zero
Rule of Five:既然有了移动语义,需要手动管理资源的类就要写全五个特殊成员函数:析构、拷贝构造、拷贝赋值、移动构造、移动赋值。上一节的 Buffer 就是完整范例("Big Five")。
Rule of Zero 才是现代 C++ 的真正追求:如果你的类不直接持有资源,就一个特殊成员函数都不要写,把资源管理全部委托给 std::string、std::vector、std::unique_ptr 这些已经写好了正确语义的成员。编译器自动生成的拷贝/移动会逐个调用成员的对应操作,行为完全正确。
这也是为什么现代 C++ 里裸指针几乎绝迹——Rule of Zero 让代码又短又对。Qt 里常见的 QString、QVector 同样遵循这个思路(外加写时复制优化)。
#include <iostream>
#include <string>
#include <vector>
#include <memory>
// Rule of Zero:一个特殊成员函数都不写,全部委托给标准库成员
class Order {
public:
Order(std::string customer, std::vector<std::string> items)
: customer_(std::move(customer)), items_(std::move(items))
{}
// 无需手写析构/拷贝/移动:
// - 编译器自动生成的拷贝构造会逐个拷贝 string 和 vector
// - 自动生成的移动构造会逐个移动它们(都是 noexcept 的可靠实现)
// - 自动生成的析构会逐个析构它们
// ~Order() = default; // 写不写都一样,写出来反而是噪音
void add_item(std::string item) {
items_.push_back(std::move(item));
}
std::size_t item_count() const { return items_.size(); }
const std::string& customer() const { return customer_; }
private:
std::string customer_;
std::vector<std::string> items_;
// 如果确实需要动态分配,用 std::unique_ptr<T> 代替裸 T*。
// 注意:一旦有 unique_ptr 成员,这个类就变成"可移动但不可拷贝",
// 下面的 Order o2 = o1; 会编译失败——这是编译器在帮你避免资源共享。
// std::unique_ptr<int> priority_;
};
int main() {
Order o1("Alice", {"书", "笔"});
Order o2 = o1; // 自动拷贝,行为正确
Order o3 = std::move(o1); // 自动移动,行为正确
o3.add_item("橡皮");
std::cout << o2.customer() << " " << o2.item_count() << "\n";
std::cout << o3.customer() << " " << o3.item_count() << "\n";
return 0;
}实践准则按优先级排列:首选 Rule of Zero(用标准库成员)→ 需要独占资源时用 unique_ptr 并 = delete 掉拷贝 → 万不得已才手写 Big Five(通常是写自己的容器、文件句柄、锁这几种场景)。
#小结
- RAII 把资源生命周期绑定到栈对象:构造获取、析构释放。它不是语法糖而是语言机制,且在异常路径下同样有效——Python 的
with、Java 的 try-with-resources 是它的等价补丁。 - C++ 的
b = a默认是值拷贝(与 Python/JS/Java 的"共享引用"根本不同),持有裸指针时浅拷贝会导致 double free。 - Rule of Three:需要析构、拷贝构造、拷贝赋值中的任一个,就要三个都写;拷贝赋值必须处理自赋值并保证异常安全(先分配后释放)。
- 右值引用
T&&绑定到临时对象;std::move(x)只是把x转成右值以选中移动版本,真正的搬运发生在移动构造函数里;被移动后的对象仍然有效但内容未指定。 - 移动构造/移动赋值应尽量标记
noexcept,否则std::vector等容器在扩容时不敢使用移动而退回拷贝。 - Rule of Zero 是最终目标:不直接持资源就不写任何特殊成员函数,全部委托给
std::string、std::vector、std::unique_ptr。
#练习
- 写一个 RAII 类
MutexGuard,构造时对传入的std::mutex&加锁、析构时解锁,并= delete掉拷贝构造。在一个多线程例子里用它替换手动lock/unlock,思考异常路径下的差异。 - 给
MyString补上移动构造和移动赋值,让它满足 Rule of Five。写测试对比MyString b = a;和MyString c = std::move(a);之后a的状态。 - 用
std::vector<MyString>存 10 万个字符串并push_back,在移动构造函数里打印计数,观察reserve()前后移动次数的变化,理解为什么reserve能提速。 - 故意把移动构造函数的
noexcept去掉,再把它放进std::vector观察扩容时是否改用拷贝(在拷贝构造里打印即可验证)。最后把一个手写裸指针的类改写成 Rule of Zero 版本(用std::vector<int>替换int*),对比两份代码的行数和出错概率。