C++ 进阶：从裸指针到智能指针的内存管理进化

1.4 异常安全

当程序抛出异常时，正常流程被打断，可能导致裸指针无法释放。

// 反面示例：异常导致泄漏
void func() {
    int* p = new int(30);
    try {
        throw runtime_error("error");
    } catch (...) {
        throw; // 重新抛出，但 delete p 不会执行
    }
    delete p;
}

1.5 智能指针的核心使命

智能指针将指针的生命周期与对象绑定，通过 RAII 机制实现自动释放。它是一个包装器类，封装裸指针并在析构函数中自动执行 delete，从根本上避免上述问题。

二、智能指针的三种核心类型

C++11 提供了三种核心智能指针，它们各有设计理念和适用场景。

2.1 unique_ptr：独占所有权的'独行侠'

unique_ptr 是最简单高效的智能指针，核心特性是独占所有权。同一时间只能有一个 unique_ptr 指向一块内存，销毁时自动释放。

2.1.1 核心原理

底层封装裸指针，禁用拷贝构造和赋值，支持移动语义。析构时调用 delete 或 delete[]。

2.1.2 基本使用

#include <memory>
#include <iostream>
using namespace std;

class Test {
public:
    Test(int id) : id_(id) { cout << "Test(" << id_ << ") 构造" << endl; }
    ~Test() { cout << "Test(" << id_ << ") 析构" << endl; }
private:
    int id_;
};

void test_unique_basic() {
    // 推荐方式：make_unique
    unique_ptr<Test> up1 = make_unique<Test>(1);
    up1->show();

    // 移动语义转移所有权
    unique_ptr<Test> up2 = move(up1);
    // up1 变为 nullptr
}

运行结果会显示对象在离开作用域时自动析构。移动操作后原指针置空，避免二次释放。管理数组时需指定 unique_ptr<T[]>。

2.1.3 最佳实践

• 优先使用 make_unique：比 new 更安全，减少泄漏风险。
• 避免滥用 get()/release()：暴露裸指针可能破坏所有权管理。
• 容器元素：vector<unique_ptr<T>> 是常见用法，避免拷贝开销。

2.2 shared_ptr：共享所有权的'社交达人'

当多个指针需共享同一块内存时，shared_ptr 应运而生。它支持共享所有权，引用计数减为 0 时才释放内存。

2.2.1 核心原理：引用计数

每个 shared_ptr 封装数据指针和控制块指针。控制块存储引用计数、弱引用计数及析构器。拷贝时引用计数加 1，析构时减 1。

2.2.2 基本使用

#include <memory>
using namespace std;

void test_shared_basic() {
    shared_ptr<Test> sp1 = make_shared<Test>(1);
    shared_ptr<Test> sp2 = sp1; // 引用计数 +1
    cout << sp1.use_count() << endl; // 输出 2
}

2.2.3 循环引用问题

两个 shared_ptr 互相持有对方引用，导致引用计数永远不为 0，造成内存泄漏。

// 循环引用示例
sp1->sp_self = sp2;
sp2->sp_self = sp1;
// 离开作用域后引用计数为 1，无法析构

2.3 weak_ptr：打破循环的'旁观者'

weak_ptr 是一种弱引用，不拥有对象所有权，仅观察 shared_ptr 管理的对象。它不会增加引用计数，因此能解决循环引用。

2.3.1 核心原理

仅存储控制块指针。创建时弱引用计数加 1。通过 lock() 获取 shared_ptr 才能访问对象。若对象已析构，lock() 返回空。

2.3.2 解决方案与使用

// 用 weak_ptr 代替 shared_ptr 打破循环
weak_ptr<Test> wp_self;

void test_solve_cycle() {
    shared_ptr<Test> sp1 = make_shared<Test>(100);
    shared_ptr<Test> sp2 = make_shared<Test>(200);
    sp1->wp_self = sp2; // 不增加 sp2 引用计数
    sp2->wp_self = sp1;
    // 离开作用域后，引用计数归零，对象正常析构
}

此外，观察者模式中常用 weak_ptr 避免主题被观察者'绑架'。

2.3.3 最佳实践

• 配合 shared_ptr 使用：不能单独存在。
• 检查有效性：使用 expired() 或判断 lock() 返回值。
• 避免长期持有：lock() 返回的 shared_ptr 会增加引用计数。

三、进阶技巧：定制删除器、转换与优化

3.1 定制删除器

默认使用 delete，特殊资源（如文件句柄）需自定义释放逻辑。

// unique_ptr 定制删除器
auto deleter = [](FILE* fp) { if(fp) fclose(fp); };
unique_ptr<FILE, decltype(deleter)> up(fopen("test.txt", "w"), deleter);

3.2 类型转换

智能指针需使用专用转换函数：

• static_pointer_cast：静态转换。
• dynamic_pointer_cast：动态转换（需多态）。
• const_pointer_cast：去除 const 限定。 注意：unique_ptr 不支持转换，因其独占性。

3.3 性能优化

1. 优先使用 unique_ptr：无额外开销。
2. 使用 make_shared：一次性分配对象和控制块，减少内存分配次数。
3. 避免不必要的拷贝：传递 const shared_ptr&。
4. 合理使用 lock()：短暂持有返回的 shared_ptr。

四、常见错误与最佳实践总结

4.1 常见错误

• 循环引用：shared_ptr 互相持有，需用 weak_ptr 解决。
• 过期访问：weak_ptr 未检查 expired() 直接解引用。
• 数组管理：unique_ptr<int> 管理数组应改为 unique_ptr<int[]>。
• 裸指针混用：不要将裸指针交给多个智能指针管理，会导致二次释放。

4.2 最佳实践

1. 能用智能指针就不用裸指针：除兼容 C 语言外。
2. 优先使用 make_shared/make_unique：更安全高效。
3. 避免滥用 get()/release()：仅在必要时使用。
4. 选择合适类型：独占用 unique_ptr，共享用 shared_ptr，观察用 weak_ptr。

总结

从裸指针的'步步惊心'到智能指针的自动化管理，C++ 内存管理经历了革命性进化。智能指针通过 RAII 将责任转移给编译器，解决了泄漏、野指针等经典问题。掌握其原理与技巧，能让代码更安全、高效。记住：智能指针不是银弹，但它是 C++ 内存管理最强大的武器。