# C++ 专题：RAII、值语义与智能指针

学习目标：理解现代 C++ 确定性资源管理的核心基石：RAII 惯用法、移动语义（Move Semantics）与独占/共享智能指针。

前置知识与范围：C++ 基础语法与指针。聚焦析构函数确定性调用、堆内存安全托管与循环引用化解。

# RAII 核心机制与栈展开

在带垃圾回收（GC）的语言中，资源释放通常取决于下一次 GC 扫描时机；而在现代 C++ 中，资源的生命周期被严格绑定到栈对象的作用域上。这种惯用法被称为 RAII（Resource Acquisition Is Initialization，资源获取即初始化）。

# 核心契约

构造函数获取资源：在对象构造时分配内存、打开文件或加锁。
析构函数释放资源：在对象离开其所在的作用域时，编译器保证其析构函数（Destructor）必然被自动调用。
异常安全（Exception Safety）：即使在函数执行中间抛出未捕获异常，C++ 运行时的**栈展开（Stack Unwinding）**机制依然会倒序逐个执行当前作用域内所有局部对象的析构函数，防止任何泄漏。

# RAII 资源守护验证

C++#include <iostream>
#include <memory>
#include <stdexcept>
#include <cassert>

static int live_resource_count = 0;

struct ResourceGuard {
    int id;
    explicit ResourceGuard(int id) : id(id) {
        live_resource_count++;
    }
    ~ResourceGuard() {
        live_resource_count--;
    }
};

void risky_operation() {
    ResourceGuard res(101);
    assert(live_resource_count == 1);
    throw std::runtime_error("something failed");
    // 正常路径永远不会走到这里
}

int main() {
    assert(live_resource_count == 0);
    try {
        risky_operation();
    } catch (const std::runtime_error&) {
        // 验证：即使抛出异常中途跳出，栈展开依然保证了析构函数被调用
        assert(live_resource_count == 0);
    }
    assert(live_resource_count == 0);

    std::cout << "RAII cleanup verified: resources active = " << live_resource_count << "\n";
}

# 值语义与移动语义

传统 C++98 默认执行逐字节或逐字段深拷贝。当传递包含巨大堆缓冲区的对象时，频繁的内存拷贝是性能杀手。C++11 引入了移动语义（Move Semantics）：通过右值引用（T&&）将资源的所有权从即将销毁的临时对象中“窃取”过来。

C++#include <iostream>
#include <vector>
#include <utility>
#include <cassert>

struct Buffer {
    std::vector<int> data;

    explicit Buffer(size_t size) : data(size, 42) {}

    // 移动构造函数：窃取源对象的动态向量指针，O(1) 转移
    Buffer(Buffer&& other) noexcept : data(std::move(other.data)) {}

    // 移动赋值操作符
    Buffer& operator=(Buffer&& other) noexcept {
        if (this != &other) {
            data = std::move(other.data);
        }
        return *this;
    }

    // 禁用隐式深拷贝（按需设计为只可移动）
    Buffer(const Buffer&) = delete;
    Buffer& operator=(const Buffer&) = delete;
};

int main() {
    Buffer b1(1000000);
    assert(b1.data.size() == 1000000);

    // std::move 显式转换为右值，触发移动构造
    Buffer b2 = std::move(b1);

    // b1 的底层内存被窃取，b2 获得了百万级元素的堆数组
    assert(b2.data.size() == 1000000);
    assert(b1.data.empty()); // 原对象进入有效但未指定状态（通常为空）

    std::cout << "move semantics verified: b2 size = " << b2.data.size() << "\n";
}

# 智能指针家族的三大支柱

现代 C++ 强烈禁止裸 new/delete。标准库 <memory> 提供了三套专属智能指针：

# 1. `std::unique_ptr<T>`（独占所有权）

语义：唯一的合法所有者，零运行时额外开销（Zero Overhead），指针大小与裸指针完全一致。
不可拷贝，只支持 std::move。

C++std::unique_ptr<int> p1 = std::make_unique<int>(42);
// std::unique_ptr<int> p2 = p1; // 编译错误！禁止拷贝
std::unique_ptr<int> p2 = std::move(p1); // 合法转移
assert(p1 == nullptr);
assert(*p2 == 42);

# 2. `std::shared_ptr<T>`（共享所有权）

语义：通过堆上的**控制块（Control Block）**维护原子引用计数（Reference Count）。
每次拷贝 shared_ptr 时计数自增 1；当任何一个副本析构时计数自减 1；直到计数归零，被托管的底层对象被释放。

# 弱引用破除循环引用

当两个对象通过 std::shared_ptr 互相持有时，其引用计数永远无法降至 0，导致严重的内存泄漏。现代 C++ 通过 std::weak_ptr 解决该问题：

C++#include <iostream>
#include <memory>
#include <cassert>

struct NodeB;

struct NodeA {
    std::shared_ptr<NodeB> next;
    ~NodeA() { std::cout << "NodeA destroyed\n"; }
};

struct NodeB {
    // 使用 weak_ptr 代替 shared_ptr，不增加 NodeA 的引用计数！
    std::weak_ptr<NodeA> prev;
    ~NodeB() { std::cout << "NodeB destroyed\n"; }
};

int main() {
    {
        auto a = std::make_shared<NodeA>();
        auto b = std::make_shared<NodeB>();

        a->next = b;      // a 强引用 b
        b->prev = a;      // b 弱引用 a，打破循环环路

        assert(a.use_count() == 1); // 因为 weak_ptr 不增加引用计数
        assert(b.use_count() == 1);
    } // 离开作用域，a 和 b 的析构函数均被正常执行，绝无内存泄漏！

    std::cout << "circular reference broken successfully\n";
}

若将 NodeB 中的 prev 改为 std::shared_ptr<NodeA>，则在离开局部作用域后，由于双方互相锁定引用计数，控制台将永远不会打印析构日志。

# 运行与验证

语言版本基线见示例基线。保存各完整程序并执行：g++ -std=c++17 main.cpp -o main，随后执行 ./main（Windows 下执行 .\main.exe）：

纯文本RAII cleanup verified: resources active = 0
NodeA destroyed
NodeB destroyed
circular reference broken successfully

异常栈展开保护、移动所有权转移与弱引用破除循环测试全部通过。