QC++ / Qt 学习之路

RAII 与拷贝控制

用 RAII 管理资源并掌握拷贝与移动语义

进阶第 5 / 48 章第一篇 · C++ 基础巩固

#RAII:C++ 最重要的设计思想

RAII(Resource Acquisition Is Initialization,资源获取即初始化)是 C++ 区别于其他语言的核心哲学。它的表述很简单:把资源的生命周期绑定到一个栈对象的生命周期上——构造函数里获取资源,析构函数里释放资源。因为栈对象的析构时机是确定的(离开作用域必然执行),资源释放也就变得确定且自动。

拷贝构造 vs 移动构造C++11 引入右值引用 T&&,使资源可以“窃取”而非复制拷贝构造:深拷贝,两块独立数据源对象 src数据块 A新对象 dst数据块 A 副本逐元素复制vector(const vector& oth) : data(new T[oth.size]) { copy(oth.begin(), ...);} // 成本:O(n) 内存分配拷贝后源对象仍然有效移动构造:指针窃取,源对象置空源对象 srcnullptr(已置空)新对象 dst原数据块 A仅复制指针vector(vector&& oth) noexcept : data(oth.data) { oth.data = nullptr;} // 成本:O(1) 无分配std::move(src)
拷贝构造与移动构造的区别:一份数据 vs 指针窃取

在其他语言里你一定见过对应的补丁:Python 的 with open(...) as f:、Java 的 try (var f = ...)、C# 的 using。它们都是为了解决"忘记关闭文件"而发明的语法糖;而 C++ 的 RAII 不是语法糖,它是语言机制本身——任何类的析构函数都会在对象生命周期结束时被自动调用,你只要把清理逻辑写进析构函数,就不存在"忘记"这回事。

更关键的是 RAII 在异常发生时依然有效。C++ 保证栈展开(stack unwinding)过程中所有已构造的局部对象都会被析构,这让"异常安全"几乎免费。Java 的 finally 也能做,但要手写;Python 的 with 同理。

C++
#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,加上移动构造和移动赋值)。

C++
#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++ 独有的性能工具,也是你从这些语言转过来时最陌生的一节。

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 同样遵循这个思路(外加写时复制优化)。

C++
#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(通常是写自己的容器、文件句柄、锁这几种场景)。

#小结

  1. RAII 把资源生命周期绑定到栈对象:构造获取、析构释放。它不是语法糖而是语言机制,且在异常路径下同样有效——Python 的 with、Java 的 try-with-resources 是它的等价补丁。
  2. C++ 的 b = a 默认是值拷贝(与 Python/JS/Java 的"共享引用"根本不同),持有裸指针时浅拷贝会导致 double free。
  3. Rule of Three:需要析构、拷贝构造、拷贝赋值中的任一个,就要三个都写;拷贝赋值必须处理自赋值并保证异常安全(先分配后释放)。
  4. 右值引用 T&& 绑定到临时对象;std::move(x) 只是把 x 转成右值以选中移动版本,真正的搬运发生在移动构造函数里;被移动后的对象仍然有效但内容未指定。
  5. 移动构造/移动赋值应尽量标记 noexcept,否则 std::vector 等容器在扩容时不敢使用移动而退回拷贝。
  6. Rule of Zero 是最终目标:不直接持资源就不写任何特殊成员函数,全部委托给 std::string、std::vector、std::unique_ptr。

#练习

  1. 写一个 RAII 类 MutexGuard,构造时对传入的 std::mutex& 加锁、析构时解锁,并 = delete 掉拷贝构造。在一个多线程例子里用它替换手动 lock/unlock,思考异常路径下的差异。
  2. 给 MyString 补上移动构造和移动赋值,让它满足 Rule of Five。写测试对比 MyString b = a; 和 MyString c = std::move(a); 之后 a 的状态。
  3. 用 std::vector<MyString> 存 10 万个字符串并 push_back,在移动构造函数里打印计数,观察 reserve() 前后移动次数的变化,理解为什么 reserve 能提速。
  4. 故意把移动构造函数的 noexcept 去掉,再把它放进 std::vector 观察扩容时是否改用拷贝(在拷贝构造里打印即可验证)。最后把一个手写裸指针的类改写成 Rule of Zero 版本(用 std::vector<int> 替换 int*),对比两份代码的行数和出错概率。
我的学习笔记笔记总览
笔记保存在本机浏览器(localStorage),换设备或清理缓存会丢失;重要内容请点「导出全部笔记」存成 .md 文件。