C++ 资源泄漏防御：利用智能指针与 Scope Guard 实现 100% 的资源回收保证 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

各位听众，下午好！

今天，我将与大家深入探讨 C++ 中一个至关重要的话题：资源管理与泄漏防御。在 C++ 的世界里，性能与控制力是其核心优势，但这也带来了对程序员更高层次的要求，尤其是在资源管理方面。手动管理资源，如内存、文件句柄、网络套接字、互斥锁等，是错误和泄漏的温床。一个微小的疏忽，可能导致程序崩溃、性能下降，甚至引发安全漏洞。

我们的目标是实现 100% 的资源回收保证。这听起来可能有些宏大，但在现代 C++ 中，这并非遥不可及的梦想。我们将通过两大核心利器——智能指针（Smart Pointers） 和 Scope Guard 机制——来构建一套坚不可摧的资源管理防线。

第一章：资源泄漏的困境与传统 C++ 的应对策略

在 C++ 中，我们经常与各种系统资源打交道。这些资源通常需要在获取后显式地释放。例如：

动态内存： new 后必须 delete，malloc 后必须 free。
文件句柄： fopen 后必须 fclose。
互斥锁： lock 后必须 unlock。
网络套接字： socket 后必须 close。
数据库连接： open 后必须 close。

手动管理这些资源面临的挑战是巨大的：

异常安全： 当函数执行过程中抛出异常时，位于异常点之后的资源释放代码将不会被执行，导致资源泄漏。
多出口点： 函数可能在多个地方通过 return 语句退出，需要确保每个出口点前都进行了资源释放。
复杂逻辑： 代码分支越多，资源获取和释放的配对就越困难，越容易遗漏。
复制/赋值语义： 对象的复制或赋值可能导致资源被重复释放，或忘记释放。

让我们通过一个简单的动态内存分配示例来感受一下这种困境：

#include <iostream>
#include <stdexcept>

void process_data_manual(int size) {
    int* data = nullptr;
    try {
        data = new int[size]; // 1. 获取资源
        // 模拟一些处理逻辑
        for (int i = 0; i < size; ++i) {
            data[i] = i * 2;
        }

        if (size > 5) {
            throw std::runtime_error("Size too large for manual processing!"); // 2. 抛出异常
        }

        // 更多逻辑...
        std::cout << "Data processed successfully." << std::endl;
        // 3. 正常返回路径
        delete[] data; // 资源释放
        data = nullptr; // 良好的习惯
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        // 4. 异常处理路径
        // 问题：如果 data 不为空，这里也需要释放！
        if (data != nullptr) {
            delete[] data; // 资源释放
            data = nullptr;
        }
        throw; // 重新抛出异常
    }

    // 如果函数有其他返回路径，比如：
    if (size == 0) {
        // delete[] data; // 在这里也需要释放！
        // 如果忘记，则泄漏
        return;
    }
}

void manual_resource_management_demo() {
    std::cout << "--- Manual Resource Management Demo ---" << std::endl;
    try {
        process_data_manual(3);
    } catch (...) {} // 捕获并忽略异常，避免程序终止

    try {
        process_data_manual(10); // 会抛出异常
    } catch (...) {}

    try {
        process_data_manual(0); // 会正常返回
    } catch (...) {}
    std::cout << "--- End Manual Demo ---" << std::endl;
}

这段代码中，我们为了确保 data 被释放，不得不在 try 块的末尾和 catch 块中都添加 delete[] data;。如果函数有多个 return 语句，每个 return 之前都需要仔细检查资源是否已释放。这显然是繁琐且容易出错的。

RAII：C++ 资源管理的基石

为了解决上述问题，C++ 引入了一个核心设计哲学：RAII (Resource Acquisition Is Initialization)，即“资源获取即初始化”。

RAII 的核心思想是将资源的生命周期与对象的生命周期绑定。当对象被创建时，它获取资源；当对象被销毁时（无论通过正常退出、函数返回还是异常），它的析构函数会自动被调用，从而释放资源。

通过 RAII，我们可以将复杂的资源管理逻辑封装在一个类中，使得客户端代码无需关心资源的具体释放细节。

让我们用一个简单的 RAII 类来管理文件句柄：

#include <cstdio> // For FILE, fopen, fclose
#include <string>
#include <stdexcept>
#include <iostream>

class FileHandler {
public:
    explicit FileHandler(const std::string& filename, const std::string& mode) {
        file_ptr_ = fopen(filename.c_str(), mode.c_str());
        if (!file_ptr_) {
            throw std::runtime_error("Failed to open file: " + filename);
        }
        std::cout << "File '" << filename << "' opened." << std::endl;
    }

    // 析构函数：保证资源释放
    ~FileHandler() {
        if (file_ptr_) {
            fclose(file_ptr_);
            std::cout << "File closed." << std::endl;
        }
    }

    // 禁用复制构造和赋值操作，以避免双重释放或所有权混乱
    FileHandler(const FileHandler&) = delete;
    FileHandler& operator=(const FileHandler&) = delete;

    // 允许移动语义，转移所有权
    FileHandler(FileHandler&& other) noexcept : file_ptr_(other.file_ptr_) {
        other.file_ptr_ = nullptr;
    }
    FileHandler& operator=(FileHandler&& other) noexcept {
        if (this != &other) {
            if (file_ptr_) { // 释放当前对象持有的资源
                fclose(file_ptr_);
            }
            file_ptr_ = other.file_ptr_;
            other.file_ptr_ = nullptr;
        }
        return *this;
    }

    // 提供访问底层资源的方法
    FILE* get() const {
        return file_ptr_;
    }

    // 检查文件是否有效
    operator bool() const {
        return file_ptr_ != nullptr;
    }

private:
    FILE* file_ptr_;
};

void process_file_raii(const std::string& filename) {
    std::cout << "nEntering process_file_raii for " << filename << std::endl;
    try {
        FileHandler file(filename, "w"); // 文件打开，资源获取
        if (!file) { // 检查是否成功打开
            std::cerr << "Failed to open file in RAII." << std::endl;
            return;
        }
        fprintf(file.get(), "Hello from RAII!n");
        // 模拟一个条件，可能导致异常或提前返回
        if (filename == "error.txt") {
            throw std::runtime_error("Simulated error during file processing.");
        }
        std::cout << "File content written." << std::endl;
        // 函数正常结束，file 对象被销毁，析构函数自动调用 fclose
    } catch (const std::exception& e) {
        std::cerr << "Caught error in process_file_raii: " << e.what() << std::endl;
        // 即使发生异常，file 对象的析构函数也会被调用
    }
    std::cout << "Exiting process_file_raii for " << filename << std::endl;
}

void raii_file_demo() {
    std::cout << "--- RAII File Management Demo ---" << std::endl;
    process_file_raii("test.txt");
    process_file_raii("error.txt");
    std::cout << "--- End RAII Demo ---" << std::endl;
}

通过 FileHandler 类，我们成功地将文件管理封装起来。无论 process_file_raii 函数是正常返回还是抛出异常，file 对象的析构函数都会被调用，从而确保文件被关闭。这就是 RAII 的强大之处。

然而，为每一种资源类型都编写一个专属的 RAII 类是繁琐且重复的工作。幸运的是，C++ 标准库已经为我们提供了通用的 RAII 机制，特别是针对内存管理的——智能指针。

第二章：智能指针——内存管理的现代化解决方案

智能指针是 C++ 标准库提供的一组 RAII 类模板，用于管理动态分配的内存。它们在对象生命周期结束时自动调用 delete，极大地简化了内存管理，并有效杜绝了内存泄漏。

C++11 引入了三种主要的智能指针：std::unique_ptr、std::shared_ptr 和 std::weak_ptr。

2.1 `std::unique_ptr`：独占所有权

std::unique_ptr 实现独占所有权语义。这意味着在任何时间点，只有一个 unique_ptr 对象可以拥有它所指向的资源。当 unique_ptr 被销毁时，它所拥有的资源也会被自动释放。

特点：

独占所有权： 不可复制，但可以移动 (move)。移动操作会将所有权从一个 unique_ptr 转移到另一个，原 unique_ptr 变为空。
轻量级： 通常与原始指针大小相同，几乎没有运行时开销。
默认 deleter： 默认使用 delete 或 delete[] 释放内存。
自定义 deleter： 可以指定自定义的 deleter 函数或 lambda 表达式来释放资源，使其可以管理非内存资源（如文件句柄）。

使用场景：

函数返回动态分配的对象（所有权转移）。
作为类成员，管理该类独有的资源。
替代裸指针作为局部变量，确保函数退出时资源被释放。
Pimpl (Pointer to Implementation) 模式。

代码示例：

#include <memory> // For unique_ptr
#include <vector>
#include <string>

class MyObject {
public:
    MyObject(int id) : id_(id) {
        std::cout << "MyObject " << id_ << " constructed." << std::endl;
    }
    ~MyObject() {
        std::cout << "MyObject " << id_ << " destructed." << std::endl;
    }
    void greet() const {
        std::cout << "Hello from MyObject " << id_ << "!" << std::endl;
    }
private:
    int id_;
};

// 函数返回 unique_ptr，所有权转移
std::unique_ptr<MyObject> create_object(int id) {
    return std::make_unique<MyObject>(id); // 推荐使用 make_unique
}

void unique_ptr_demo() {
    std::cout << "n--- std::unique_ptr Demo ---" << std::endl;

    // 1. 基本使用
    std::unique_ptr<MyObject> obj1 = std::make_unique<MyObject>(1);
    obj1->greet();

    // 2. 独占所有权，不能复制
    // std::unique_ptr<MyObject> obj2 = obj1; // 编译错误！
    // obj1 = std::make_unique<MyObject>(3); // 编译错误！

    // 3. 可以移动所有权
    std::unique_ptr<MyObject> obj2 = std::move(obj1); // obj1 变为空
    if (obj1) { // obj1 此时为 nullptr
        obj1->greet();
    } else {
        std::cout << "obj1 is now empty." << std::endl;
    }
    obj2->greet(); // obj2 现在拥有 MyObject(1)

    // 4. 数组管理
    std::unique_ptr<int[]> arr = std::make_unique<int[]>(5);
    for (int i = 0; i < 5; ++i) {
        arr[i] = i * 10;
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    // 5. 函数返回 unique_ptr
    std::unique_ptr<MyObject> obj3 = create_object(4);
    obj3->greet();

    // 6. 自定义 deleter (例如管理 FILE*)
    std::unique_ptr<FILE, decltype(&fclose)> file_ptr(fopen("unique_file.txt", "w"), &fclose);
    if (file_ptr) {
        fprintf(file_ptr.get(), "This is managed by unique_ptr with custom deleter.n");
        std::cout << "unique_file.txt written." << std::endl;
    } else {
        std::cerr << "Failed to open unique_file.txt" << std::endl;
    }
    // file_ptr 离开作用域时，fclose 会被调用

    std::cout << "--- End std::unique_ptr Demo ---" << std::endl;
}

2.2 `std::shared_ptr`：共享所有权

std::shared_ptr 实现共享所有权语义。多个 shared_ptr 可以共同拥有同一个资源。它通过引用计数（reference count）来跟踪有多少个 shared_ptr 正在管理该资源。当最后一个 shared_ptr 被销毁或重置时，资源才会被释放。

特点：

共享所有权： 可以复制，每次复制都会增加引用计数。
引用计数： 内部维护一个引用计数，当计数归零时释放资源。
额外开销： 相比 unique_ptr，shared_ptr 有额外的内存开销（用于存储引用计数和自定义 deleter），以及一些运行时开销（原子操作增加/减少引用计数）。
默认 deleter： 默认使用 delete 或 delete[]。
自定义 deleter： 可以指定自定义的 deleter。

使用场景：

当多个对象需要共享同一资源的访问权，并且共同决定资源的生命周期时。
在容器中存储指向共享对象的指针。
工厂函数返回共享对象。

代码示例：

#include <memory> // For shared_ptr
#include <vector>
#include <string>

class SharedObject {
public:
    SharedObject(int id) : id_(id) {
        std::cout << "SharedObject " << id_ << " constructed." << std::endl;
    }
    ~SharedObject() {
        std::cout << "SharedObject " << id_ << " destructed." << std::endl;
    }
    void greet() const {
        std::cout << "Hello from SharedObject " << id_ << "!" << std::endl;
    }
private:
    int id_;
};

void process_shared_object(std::shared_ptr<SharedObject> obj) {
    std::cout << "  Inside process_shared_object. Ref count: " << obj.use_count() << std::endl;
    obj->greet();
}

void shared_ptr_demo() {
    std::cout << "n--- std::shared_ptr Demo ---" << std::endl;

    // 1. 基本使用
    std::shared_ptr<SharedObject> s_obj1 = std::make_shared<SharedObject>(10);
    std::cout << "s_obj1 ref count: " << s_obj1.use_count() << std::endl; // 1

    // 2. 复制，增加引用计数
    std::shared_ptr<SharedObject> s_obj2 = s_obj1;
    std::cout << "s_obj1 ref count: " << s_obj1.use_count() << std::endl; // 2
    std::cout << "s_obj2 ref count: " << s_obj2.use_count() << std::endl; // 2

    // 3. 作为函数参数传递
    process_shared_object(s_obj1); // 传递时，引用计数会短暂增加到 3，函数返回后恢复到 2
    std::cout << "After function call. s_obj1 ref count: " << s_obj1.use_count() << std::endl; // 2

    // 4. 重置或离开作用域
    s_obj1.reset(); // s_obj1 变为空，引用计数减 1
    std::cout << "After s_obj1 reset. s_obj2 ref count: " << s_obj2.use_count() << std::endl; // 1
    if (!s_obj1) {
        std::cout << "s_obj1 is now empty." << std::endl;
    }

    // s_obj2 离开作用域时，引用计数归零，SharedObject(10) 被销毁

    // 5. 存储在容器中
    std::vector<std::shared_ptr<SharedObject>> objects;
    objects.push_back(std::make_shared<SharedObject>(20));
    objects.push_back(s_obj2); // 再次复制 s_obj2 (实际是 SharedObject(10))
    std::cout << "After adding to vector. s_obj2 ref count: " << s_obj2.use_count() << std::endl; // 2

    // 6. 自定义 deleter
    std::shared_ptr<int, void(*)(int*)> raw_int_ptr(new int(100), [](int* p){
        std::cout << "Custom deleter for int* called. Deleting " << *p << std::endl;
        delete p;
    });
    // raw_int_ptr 离开作用域时，lambda 会被调用

    std::cout << "--- End std::shared_ptr Demo ---" << std::endl;
}

2.3 `std::weak_ptr`：解决循环引用问题

std::weak_ptr 是一种非拥有型智能指针。它指向一个 std::shared_ptr 管理的对象，但不会增加该对象的引用计数。它主要用于解决 shared_ptr 可能导致的循环引用问题，从而避免内存泄漏。

特点：

非拥有型： 不增加引用计数，不控制对象的生命周期。
观察者： 仅提供对 shared_ptr 管理的对象的访问能力。
需要锁住： 要访问 weak_ptr 指向的对象，必须先通过 lock() 方法获取一个 shared_ptr。如果对象已被销毁，lock() 会返回一个空的 shared_ptr。

使用场景：

当两个对象互相持有对方的 shared_ptr 时（循环引用），将其中一方改为 weak_ptr。
缓存机制中，当缓存的对象生命周期不确定时。

循环引用示例：

#include <memory>
#include <iostream>
#include <vector>

class B; // 前向声明

class A {
public:
    std::shared_ptr<B> b_ptr;
    int id;

    A(int i) : id(i) { std::cout << "A " << id << " constructed." << std::endl; }
    ~A() { std::cout << "A " << id << " destructed." << std::endl; }
    void print() { std::cout << "A " << id << " has B: " << (b_ptr ? std::to_string(b_ptr->id) : "nullptr") << std::endl; }
};

class B {
public:
    // std::shared_ptr<A> a_ptr; // 会导致循环引用
    std::weak_ptr<A> a_ptr; // 解决循环引用
    int id;

    B(int i) : id(i) { std::cout << "B " << id << " constructed." << std::endl; }
    ~B() { std::cout << "B " << id << " destructed." << std::endl; }
    void print() {
        std::cout << "B " << id << " has A: ";
        if (auto sharedA = a_ptr.lock()) { // 尝试获取 shared_ptr
            std::cout << sharedA->id << std::endl;
        } else {
            std::cout << "nullptr (A has been destructed)" << std::endl;
        }
    }
};

void cyclic_dependency_demo() {
    std::cout << "n--- std::weak_ptr Demo (Cyclic Dependency) ---" << std::endl;

    std::cout << "Attempting to create A and B with shared_ptr (potential leak if B held shared_ptr<A>)" << std::endl;
    // 在这里，A 和 B 都在各自的作用域内被创建
    // 如果 B 内部是 shared_ptr<A> 而不是 weak_ptr<A>，
    // 那么 A 的引用计数永远不会降为 0 (因为它被 B 引用)，
    // B 的引用计数也永远不会降为 0 (因为它被 A 引用)。
    // 结果是 A 和 B 都不会被析构，内存泄漏。

    { // 限制 A 和 B 的生命周期
        std::shared_ptr<A> a = std::make_shared<A>(100);
        std::shared_ptr<B> b = std::make_shared<B>(200);

        std::cout << "Initial A ref count: " << a.use_count() << std::endl; // 1
        std::cout << "Initial B ref count: " << b.use_count() << std::endl; // 1

        a->b_ptr = b; // A 拥有 B
        b->a_ptr = a; // B 观察 A (使用 weak_ptr)

        std::cout << "After assigning pointers:" << std::endl;
        std::cout << "A ref count: " << a.use_count() << std::endl; // 1 (B's weak_ptr doesn't count)
        std::cout << "B ref count: " << b.use_count() << std::endl; // 2 (A's shared_ptr counts)

        a->print();
        b->print();
    } // a 和 b 离开作用域，它们的引用计数会减少

    // 观察析构函数的调用顺序，证明没有循环引用泄漏
    std::cout << "Leaving scope. Objects should be destructed." << std::endl;

    std::cout << "--- End std::weak_ptr Demo ---" << std::endl;
}

在上面的例子中，如果 B 持有 std::shared_ptr<A> a_ptr，那么当 a 和 b 离开作用域时，它们的引用计数都将是 1（因为它们互相持有），导致它们永远不会被析构，从而造成内存泄漏。通过将 B 中的指针改为 std::weak_ptr<A>，B 只是观察 A 而不拥有它，A 的引用计数不会因此增加。当 a 离开作用域时，A 的引用计数降为 0，A 被析构。随后 b 离开作用域，它的引用计数也降为 0，B 被析构。

2.4 智能指针选择指南

智能指针	所有权语义	复制/移动	引用计数	运行时开销	适用场景	备注
`std::unique_ptr`	独占	仅移动	无	最小	独占资源、Pimpl、工厂函数返回、数组	C++11 起，推荐使用 `std::make_unique`
`std::shared_ptr`	共享	复制和移动	有	中等	共享资源、复杂对象图、容器存储	C++11 起，推荐使用 `std::make_shared`
`std::weak_ptr`	观察者	复制和移动	无	最小	解决 `shared_ptr` 循环引用、缓存管理	C++11 起，需配合 `shared_ptr` 使用，通过 `lock()` 获取 `shared_ptr`
`std::auto_ptr`	独占 (已废弃)	复制	无	最小	独占资源 (但复制语义存在缺陷)	C++11 废弃，C++17 移除。不应再使用。

最佳实践：

优先使用 std::unique_ptr，因为它开销最小且语义最清晰。
只有在确实需要共享资源所有权时才使用 std::shared_ptr。
使用 std::weak_ptr 来打破 shared_ptr 之间的循环引用。
使用 std::make_unique 和 std::make_shared 来创建智能指针，它们更高效且异常安全。

第三章：Scope Guard——通用资源管理的瑞士军刀

智能指针完美解决了动态内存的 RAII 管理。但是，C++ 程序中的资源远不止内存。我们还有文件句柄、互斥锁、网络连接、数据库事务、GUI 资源等等。为每一种非内存资源都创建一个专门的 RAII 类是可行的，但非常繁琐。

这时，Scope Guard (范围守卫) 机制就派上用场了。Scope Guard 是一种通用的 RAII 模式，它允许您在任何作用域退出时（无论是正常退出还是异常退出）执行一个预定义的动作。它本质上是一个轻量级的 RAII 类，其析构函数执行一个可调用对象（如 lambda 表达式、函数对象）。

3.1 Scope Guard 的基本思想

Scope Guard 的核心是一个类，它接受一个可调用对象作为构造函数参数，并在其析构函数中调用这个可调用对象。

3.2 简单实现 (C++11/14)

#include <functional> // For std::function
#include <utility>    // For std::move

class ScopeGuard {
public:
    // 构造函数接受一个可调用对象
    template<typename F>
    explicit ScopeGuard(F&& f) : func_(std::forward<F>(f)), active_(true) {}

    // 析构函数：如果 active_ 为 true，则执行 func_
    ~ScopeGuard() {
        if (active_) {
            func_();
        }
    }

    // 禁用复制构造和赋值操作
    ScopeGuard(const ScopeGuard&) = delete;
    ScopeGuard& operator=(const ScopeGuard&) = delete;

    // 允许移动构造和赋值操作
    ScopeGuard(ScopeGuard&& other) noexcept
        : func_(std::move(other.func_)), active_(other.active_) {
        other.active_ = false; // 转移所有权后，原对象不再执行操作
    }

    ScopeGuard& operator=(ScopeGuard&& other) noexcept {
        if (this != &other) {
            if (active_) { // 释放当前可能持有的资源（虽然这里没有）
                func_();
            }
            func_ = std::move(other.func_);
            active_ = other.active_;
            other.active_ = false;
        }
        return *this;
    }

    // 显式取消执行，例如在操作成功后不再需要回滚
    void dismiss() noexcept {
        active_ = false;
    }

private:
    std::function<void()> func_; // 存储可调用对象
    bool active_; // 控制是否执行
};

// 辅助函数或宏，使 ScopeGuard 更易用
// C++17 可以使用 if constexpr 简化
template<typename F>
ScopeGuard make_scope_guard(F&& f) {
    return ScopeGuard(std::forward<F>(f));
}

// 更强大的宏，模拟 D 语言的 scope(exit) 语法
// 需要一个独特的变量名
#define CONCAT_IMPL(x, y) x##y
#define CONCAT(x, y) CONCAT_IMPL(x, y)
#define ON_SCOPE_EXIT(func) ScopeGuard CONCAT(scope_guard_object_, __LINE__)(func)

3.3 Scope Guard 的应用场景

现在，让我们看看如何使用 ScopeGuard 来管理各种非内存资源。

*1. 文件句柄管理 (`FILE`)**

void process_file_with_scope_guard(const std::string& filename) {
    std::cout << "nEntering process_file_with_scope_guard for " << filename << std::endl;
    FILE* file = fopen(filename.c_str(), "w");
    if (!file) {
        std::cerr << "Failed to open file: " << filename << std::endl;
        return;
    }

    // 在这里创建 ScopeGuard，无论函数如何退出，都会调用 fclose(file)
    ON_SCOPE_EXIT([&]() {
        if (file) { // 确保文件句柄有效
            fclose(file);
            std::cout << "File '" << filename << "' closed by ScopeGuard." << std::endl;
        }
    });

    fprintf(file, "Data written with Scope Guard.n");
    std::cout << "Data written to " << filename << std::endl;

    if (filename == "error_sg.txt") {
        throw std::runtime_error("Simulated error in file processing with Scope Guard.");
    }
    // file 会在 ScopeGuard 析构时自动关闭
    std::cout << "Exiting process_file_with_scope_guard for " << filename << std::endl;
}

void scope_guard_file_demo() {
    std::cout << "--- ScopeGuard File Demo ---" << std::endl;
    try {
        process_file_with_scope_guard("success_sg.txt");
    } catch (const std::exception& e) {
        std::cerr << "Caught error: " << e.what() << std::endl;
    }

    try {
        process_file_with_scope_guard("error_sg.txt");
    } catch (const std::exception& e) {
        std::cerr << "Caught error: " << e.what() << std::endl;
    }
    std::cout << "--- End ScopeGuard File Demo ---" << std::endl;
}

2. 互斥锁 (pthread_mutex_t)

在多线程编程中，互斥锁的加锁和解锁必须严格配对，否则容易死锁或数据竞态。Scope Guard 是完美的解决方案。

#include <pthread.h> // For pthread_mutex_t
#include <chrono>    // For std::chrono
#include <thread>    // For std::this_thread

pthread_mutex_t my_mutex = PTHREAD_MUTEX_INITIALIZER;
int shared_data = 0;

void access_shared_resource_with_scope_guard(int thread_id) {
    std::cout << "Thread " << thread_id << " attempting to lock mutex." << std::endl;
    pthread_mutex_lock(&my_mutex); // 获取锁

    // 创建 ScopeGuard，确保无论如何都会解锁
    ON_SCOPE_EXIT([&]() {
        pthread_mutex_unlock(&my_mutex);
        std::cout << "Thread " << thread_id << " unlocked mutex by ScopeGuard." << std::endl;
    });

    // 临界区操作
    shared_data++;
    std::cout << "Thread " << thread_id << " incremented shared_data to " << shared_data << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(50)); // 模拟工作

    if (thread_id == 2) {
        throw std::runtime_error("Simulated error in thread 2 during critical section.");
    }

    // 离开作用域时，互斥锁会被自动解锁
    std::cout << "Thread " << thread_id << " finished critical section." << std::endl;
}

void scope_guard_mutex_demo() {
    std::cout << "n--- ScopeGuard Mutex Demo ---" << std::endl;
    std::vector<std::thread> threads;
    for (int i = 0; i < 3; ++i) {
        threads.emplace_back([i]() {
            try {
                access_shared_resource_with_scope_guard(i + 1);
            } catch (const std::exception& e) {
                std::cerr << "Thread " << i + 1 << " caught error: " << e.what() << std::endl;
            }
        });
    }

    for (auto& t : threads) {
        t.join();
    }
    std::cout << "Final shared_data: " << shared_data << std::endl;
    std::cout << "--- End ScopeGuard Mutex Demo ---" << std::endl;
}

3. 数据库事务管理

在数据库操作中，事务通常需要提交（commit）或回滚（rollback）。Scope Guard 可以优雅地处理这种情况。

#include <string>
#include <iostream>

// 模拟数据库连接和事务
class MockDBConnection {
public:
    void begin_transaction() { std::cout << "DB: Transaction started." << std::endl; in_transaction_ = true; }
    void commit() { std::cout << "DB: Transaction committed." << std::endl; in_transaction_ = false; }
    void rollback() { std::cout << "DB: Transaction rolled back." << std::endl; in_transaction_ = false; }
    bool is_in_transaction() const { return in_transaction_; }
private:
    bool in_transaction_ = false;
};

void perform_db_operation(MockDBConnection& db, bool should_fail) {
    std::cout << "nEntering perform_db_operation (should_fail=" << (should_fail ? "true" : "false") << ")" << std::endl;
    db.begin_transaction();

    bool committed = false; // 标记是否已提交

    // 创建 ScopeGuard，默认回滚。如果成功，则 dismiss()
    ON_SCOPE_EXIT([&]() {
        if (db.is_in_transaction() && !committed) {
            db.rollback();
        }
    });

    std::cout << "DB: Executing some SQL statements..." << std::endl;
    // 模拟 SQL 操作
    std::this_thread::sleep_for(std::chrono::milliseconds(20));

    if (should_fail) {
        throw std::runtime_error("Simulated DB operation failure.");
    }

    std::cout << "DB: All operations successful. Preparing to commit." << std::endl;
    db.commit();
    committed = true; // 标记已提交，防止 ScopeGuard 再次回滚
    // 如果没有 dismiss()，ScopeGuard 仍然会尝试执行其 lambda，
    // 但因为 committed 为 true，不会再次回滚。
    // 如果需要更严格的控制，可以在 commit() 后调用 scope_guard_object_xxx.dismiss();

    std::cout << "Exiting perform_db_operation." << std::endl;
}

void scope_guard_db_demo() {
    std::cout << "--- ScopeGuard DB Transaction Demo ---" << std::endl;
    MockDBConnection db_conn;

    try {
        perform_db_operation(db_conn, false); // 成功路径
    } catch (const std::exception& e) {
        std::cerr << "Caught DB error: " << e.what() << std::endl;
    }

    try {
        perform_db_operation(db_conn, true); // 失败路径
    } catch (const std::exception& e) {
        std::cerr << "Caught DB error: " << e.what() << std::endl;
    }
    std::cout << "--- End ScopeGuard DB Transaction Demo ---" << std::endl;
}

通过这些例子，我们可以看到 ScopeGuard 的强大和通用性。它允许我们在不修改现有资源管理接口的前提下，为任意资源获取-释放对实现 RAII 语义。

第四章：高级话题与最佳实践

4.1 `std::make_unique` 和 `std::make_shared`

始终优先使用 std::make_unique 和 std::make_shared 来创建智能指针，而不是直接使用 new。

优势：

异常安全： 考虑 func(std::shared_ptr<T>(new T()), std::shared_ptr<U>(new U()))。如果在 new U() 之前发生异常，并且 new T() 已经执行，那么 T 将会泄漏，因为 shared_ptr<T> 还没来得及构造。make_shared 将内存分配和对象构造合二为一，避免了这种中间状态。
效率： make_shared 只进行一次内存分配（同时分配对象和控制块），而 new T() + shared_ptr<T> 会进行两次内存分配。make_unique 也能在某些情况下优化性能。

// 推荐
auto my_obj_ptr = std::make_unique<MyObject>(1);
auto shared_obj_ptr = std::make_shared<SharedObject>(10);

// 不推荐 (存在潜在异常安全问题和效率问题)
// std::unique_ptr<MyObject> my_obj_ptr(new MyObject(1));
// std::shared_ptr<SharedObject> shared_obj_ptr(new SharedObject(10));

4.2 自定义 Deleter

智能指针允许您指定自定义的 deleter，这使得它们能够管理任何非内存资源。

std::unique_ptr 的自定义 deleter： 作为模板参数的一部分，需要知道 deleter 的类型。

// 之前的文件句柄示例
std::unique_ptr<FILE, decltype(&fclose)> file_ptr(fopen("unique_file.txt", "w"), &fclose);

或者使用 lambda：

std::unique_ptr<int, std::function<void(int*)>> custom_deleter_ptr(new int[10], [](int* p){
    std::cout << "Custom deleter for int[] called." << std::endl;
    delete[] p;
});

std::shared_ptr 的自定义 deleter： 作为构造函数的第二个参数，无需在模板参数中指定类型（类型擦除）。

std::shared_ptr<int> custom_deleter_ptr(new int[10], [](int* p){
    std::cout << "Custom deleter for int[] called." << std::endl;
    delete[] p;
});

4.3 智能指针与裸指针的混合使用

尽量避免混合使用智能指针和裸指针。如果必须混合，请遵循以下原则：

不要将裸指针转换为 shared_ptr 两次： 这会导致两个独立的控制块，从而导致双重释放。
不要将 unique_ptr 管理的裸指针传递给 shared_ptr： 除非你打算转移所有权。
使用 get() 临时获取裸指针： 如果需要将智能指针管理的对象传递给接受裸指针的旧 C 风格 API，可以使用 get() 方法。但请注意，裸指针的生命周期不能超过智能指针。
std::addressof： 当需要对象的实际地址而不是 operator& 可能重载的地址时使用。

void old_c_api_func(MyObject* obj) {
    if (obj) {
        obj->greet();
    }
}

void mixed_ptr_demo() {
    std::cout << "n--- Mixed Pointers Demo ---" << std::endl;
    std::unique_ptr<MyObject> u_obj = std::make_unique<MyObject>(5);
    old_c_api_func(u_obj.get()); // 安全地传递裸指针

    // 错误示例：将裸指针转换为 shared_ptr 两次
    MyObject* raw_ptr = new MyObject(6);
    std::shared_ptr<MyObject> s_ptr1(raw_ptr);
    // std::shared_ptr<MyObject> s_ptr2(raw_ptr); // 极度危险！会导致双重释放！

    // 正确的做法：
    std::shared_ptr<MyObject> s_ptr3 = std::make_shared<MyObject>(7);
    std::shared_ptr<MyObject> s_ptr4 = s_ptr3; // 复制，增加引用计数
    std::cout << "--- End Mixed Pointers Demo ---" << std::endl;
}

4.4 智能指针作为函数参数和返回值

按值传递 shared_ptr： 当函数需要共享所有权，或者需要延长对象生命周期时。
按常量引用传递 shared_ptr<const T>： 如果函数只是读取对象内容，不修改对象，也不需要共享所有权。
按引用传递 shared_ptr<T>&： 当函数需要修改 shared_ptr 本身（例如，让它指向另一个对象）时。
返回 unique_ptr： 允许调用者接管对象的独占所有权。C++11/14 通过移动语义支持，C++17 更是有强制的返回值优化 (guaranteed copy elision)。
返回 shared_ptr： 当函数作为工厂，返回一个共享所有权的对象时。

4.5 线程安全

std::shared_ptr 的引用计数本身是线程安全的（通过原子操作）。这意味着在多线程环境中，对 shared_ptr 对象的复制、赋值、销毁等操作是安全的，不会导致引用计数损坏。

然而，shared_ptr 所管理的对象本身并不是线程安全的。 如果多个线程同时访问和修改 shared_ptr 指向的同一个对象，仍然需要额外的同步机制（如互斥锁）来保护该对象的内部状态。

4.6 Pimpl Idiom

Pimpl (Pointer to Implementation) 模式是 unique_ptr 的一个经典应用。它通过将类的私有实现细节隐藏在一个 unique_ptr 指向的内部类中，来减少编译依赖，从而加快编译速度，并提供更好的 ABI 兼容性。

// MyClass.h
#include <memory> // For std::unique_ptr

class MyClass {
public:
    MyClass();
    ~MyClass(); // 必须在 .cpp 文件中实现，因为 Impl 的完整定义在那里
    void do_something();

private:
    class Impl; // 前向声明内部实现类
    std::unique_ptr<Impl> pimpl_; // 独占所有权
};

// MyClass.cpp
#include "MyClass.h"
#include <iostream>
#include <string>

// Impl 的完整定义
class MyClass::Impl {
public:
    Impl(const std::string& name) : name_(name) {
        std::cout << "Impl constructed for " << name_ << std::endl;
    }
    ~Impl() {
        std::cout << "Impl destructed for " << name_ << std::endl;
    }
    void do_something_impl() {
        std::cout << "Impl for " << name_ << " is doing something." << std::endl;
    }
private:
    std::string name_;
    // 更多私有成员...
};

MyClass::MyClass() : pimpl_(std::make_unique<Impl>("MyClassInstance")) {}

// 析构函数必须在 Impl 完整定义可见的地方实现
MyClass::~MyClass() = default; // C++11/14 之后，如果 Impl 定义可见，可以默认

void MyClass::do_something() {
    pimpl_->do_something_impl();
}

void pimpl_demo() {
    std::cout << "n--- Pimpl Idiom Demo ---" << std::endl;
    MyClass obj;
    obj.do_something();
    std::cout << "--- End Pimpl Idiom Demo ---" << std::endl;
}

总结与展望

通过本讲座，我们深入探讨了 C++ 资源管理的核心挑战以及现代 C++ 提供的高效解决方案。我们从手动资源管理的困境出发，理解了 RAII 这一基石原则，并在此基础上详细剖析了智能指针 std::unique_ptr、std::shared_ptr 和 std::weak_ptr 如何彻底革新内存管理。

随后，我们介绍了强大的 Scope Guard 机制，它将 RAII 的理念推广到所有非内存资源，为文件句柄、互斥锁、数据库事务等提供了统一且异常安全的管理方式。结合智能指针和 Scope Guard，我们能够为 C++ 应用程序实现几乎 100% 的资源回收保证，从而编写出更加健壮、可靠和易于维护的代码。

拥抱这些现代 C++ 资源管理工具，是每一位 C++ 开发者迈向更高级编程的必经之路。它们不仅能显著减少资源泄漏和程序崩溃的风险，更能提升代码的可读性和可维护性，让您能够将更多精力投入到核心业务逻辑的实现上。

第一章：资源泄漏的困境与传统 C++ 的应对策略

RAII：C++ 资源管理的基石

第二章：智能指针——内存管理的现代化解决方案

2.1 std::unique_ptr：独占所有权

2.2 std::shared_ptr：共享所有权

2.3 std::weak_ptr：解决循环引用问题

2.4 智能指针选择指南

第三章：Scope Guard——通用资源管理的瑞士军刀

3.1 Scope Guard 的基本思想

3.2 简单实现 (C++11/14)

3.3 Scope Guard 的应用场景

第四章：高级话题与最佳实践

4.1 std::make_unique 和 std::make_shared

4.2 自定义 Deleter

4.3 智能指针与裸指针的混合使用

4.4 智能指针作为函数参数和返回值

4.5 线程安全

4.6 Pimpl Idiom

总结与展望

发表回复 取消回复

2.1 `std::unique_ptr`：独占所有权

2.2 `std::shared_ptr`：共享所有权

2.3 `std::weak_ptr`：解决循环引用问题

4.1 `std::make_unique` 和 `std::make_shared`

发表回复取消回复