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

1.4 异常安全

当程序发生异常时，正常的执行流程会被打断，可能导致裸指针无法被释放。

// 反面示例：异常导致的内存泄漏
void func() {
    int* p = new int(30);
    try {
        throw runtime_error("something wrong");
    } catch (...) {
        throw; // 重新抛出异常，未处理 p 的释放
    }
    delete p; // 永远不会执行
}

1.5 智能指针的核心使命

面对裸指针的种种问题，智能指针的核心设计思想应运而生：将指针的生命周期管理与对象的生命周期绑定，通过 RAII 机制，实现内存的自动释放。

简单来说，智能指针是一个'包装器类'，它封装了裸指针，并在其析构函数中自动执行 delete 操作。

二、智能指针的三驾马车：unique_ptr、shared_ptr、weak_ptr

C++11 标准库提供了三种核心智能指针：unique_ptr、shared_ptr和weak_ptr。

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

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

2.1.1 unique_ptr 的核心原理

unique_ptr的底层实现非常简洁：

• 封装一个裸指针；
• 禁用拷贝构造函数和拷贝赋值运算符，确保所有权无法被复制；
• 支持移动构造函数和移动赋值运算符，允许所有权的转移；
• 析构函数中调用 delete 或 delete[] 释放内存。

2.1.2 unique_ptr 的基本使用

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

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

void test_unique_ptr_basic() {
    // 方式 1：通过 make_unique 创建（推荐）
    unique_ptr<Test> up1 = make_unique<Test>(1);
    up1->show();

    // 方式 2：通过 new 创建（不推荐）
    unique_ptr<Test> up2(new Test(2));

    // 错误：不允许拷贝构造
    // unique_ptr<Test> up3 = up1;

    // 正确：移动构造（转移所有权）
    unique_ptr<Test> up5 = move(up1);
    up5->show();

    // 重置指针
    up5.reset(new Test(5));
}

2.1.3 unique_ptr 的使用场景与最佳实践

• 独占资源所有权：当一块内存只需要被一个指针管理时，优先使用 unique_ptr。
• 作为函数参数 / 返回值：传递临时对象的所有权。
• 管理局部动态对象：替代裸指针。
• 容器元素：vector<unique_ptr<T>> 是常见用法。

最佳实践：优先使用 make_unique 创建 unique_ptr，避免手动调用 get()、release()。

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

shared_ptr支持共享所有权，多个 shared_ptr 可以指向同一块内存，当最后一个 shared_ptr 被销毁时，内存才会被释放。

2.2.1 shared_ptr 的核心原理：引用计数

shared_ptr的核心机制是引用计数（Reference Counting）：

• 每个 shared_ptr 都封装了一个'数据指针'和一个'控制块指针'；
• 控制块中存储了引用计数、弱引用计数等信息；
• 当创建一个新的 shared_ptr 指向对象时，引用计数加 1；
• 当引用计数减为 0 时，控制块会调用析构器释放对象内存。

2.2.2 shared_ptr 的基本使用

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

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

void test_shared_ptr_basic() {
    shared_ptr<Test> sp1 = make_shared<Test>(1);
    cout << "sp1 use_count: " << sp1.use_count() << endl; // 1

    // 拷贝构造：引用计数加 1
    shared_ptr<Test> sp2 = sp1;
    cout << "sp1 use_count after copy: " << sp1.use_count() << endl; // 2

    // 移动构造：引用计数不变
    shared_ptr<Test> sp4 = move(sp1);
    cout << "sp4 use_count after move: " << sp4.use_count() << endl; // 2
}

2.2.3 循环引用：shared_ptr 的阿喀琉斯之踵

循环引用是指两个或多个 shared_ptr 互相持有对方的引用，导致它们的引用计数永远无法减为 0，从而造成内存泄漏。

为了解决循环引用问题，C++ 标准库引入了第三种智能指针 —— weak_ptr。

2.3 weak_ptr：打破循环的旁观者

weak_ptr是一种'弱引用'智能指针，它的核心特性是不拥有对象的所有权，仅能观察 shared_ptr 所管理的对象。

2.3.1 weak_ptr 的核心原理

• weak_ptr仅存储控制块的指针，不存储数据指针；
• 创建 weak_ptr 时，会将控制块的弱引用计数加 1；
• weak_ptr无法直接访问对象，必须通过 lock() 方法获取一个 shared_ptr 才能访问对象；
• 可以通过 expired() 方法判断所观察的对象是否已被析构。

2.3.2 weak_ptr 的基本使用与循环引用解决方案

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

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

void test_weak_ptr_solve_cycle() {
    shared_ptr<Test> sp1 = make_shared<Test>(100);
    shared_ptr<Test> sp2 = make_shared<Test>(200);

    // 用 weak_ptr 代替 shared_ptr，避免循环引用
    sp1->wp_self = sp2;
    sp2->wp_self = sp1;

    cout << "sp1 use_count: " << sp1.use_count() << endl; // 1
    cout << "sp2 use_count: " << sp2.use_count() << endl; // 1

    // 通过 lock() 访问对方
    if (auto sp = sp1->wp_self.lock()) {
        cout << "sp1 access sp2: ";
        sp->show();
    }
}

2.3.3 weak_ptr 的使用场景与最佳实践

• 解决 shared_ptr 的循环引用问题：将循环引用中的一方改为 weak_ptr。
• 观察者模式：观察者持有主题的 weak_ptr，避免主题被观察者'绑架'。
• 缓存场景：缓存对象的 weak_ptr，当对象被销毁时，缓存自动失效。

三、智能指针的进阶技巧：定制删除器、类型转换与性能优化

3.1 定制删除器：处理特殊资源释放

默认情况下，智能指针会使用 delete 或 delete[] 释放内存。但在某些场景下，我们需要自定义释放逻辑。

3.1.1 unique_ptr 的定制删除器

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

void close_file(FILE* fp) {
    if (fp) fclose(fp);
}

void test_custom_deleter_unique() {
    FILE* fp = fopen("test.txt", "w");
    unique_ptr<FILE, decltype(&close_file)> up2(fp, close_file);
}

3.1.2 shared_ptr 的定制删除器

void test_custom_deleter_shared() {
    FILE* fp = fopen("test.txt", "w");
    shared_ptr<FILE> sp2(fp, close_file);
}

3.2 智能指针的类型转换

C++ 标准库提供了专门的类型转换函数：

• static_pointer_cast：对应 static_cast。
• dynamic_pointer_cast：对应 dynamic_cast。
• const_pointer_cast：对应 const_cast。

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

class Base { public: virtual void show() {} virtual ~Base() {} };
class Derived : public Base { public: void show() override {} };

void test_pointer_cast() {
    shared_ptr<Base> sp_base = make_shared<Derived>();
    if (auto sp_derived = dynamic_pointer_cast<Derived>(sp_base)) {
        sp_derived->show();
    }
}

注意：dynamic_pointer_cast 仅对多态类型有效，unique_ptr不支持这些转换。

3.3 智能指针的性能优化

• 优先使用 unique_ptr：性能几乎与裸指针一致。
• 使用 make_shared 减少内存分配：一次性分配对象和控制块。
• 避免不必要的 shared_ptr 拷贝：通过 const& 传递。
• 合理使用 weak_ptr 的 lock()：短暂持有 lock() 返回的 shared_ptr。

四、智能指针的避坑指南：常见错误与最佳实践总结

4.1 常见错误

1. shared_ptr 的循环引用：导致内存泄漏。
2. weak_ptr 访问已过期的对象：未检查 expired() 或 lock() 返回的 shared_ptr 是否为空。
3. 管理数组时使用 unique_ptr 而非 unique_ptr<T[]>：导致析构时调用 delete 而非 delete[]。
4. unique_ptr 的拷贝操作：unique_ptr 禁用拷贝，强行拷贝会编译失败。
5. 使用 get() 返回的裸指针创建智能指针：导致二次释放。

4.2 最佳实践总结

1. 优先使用智能指针，替代裸指针。
2. 优先使用 make_shared 和 make_unique。
3. 不混合使用裸指针和智能指针。
4. 避免 get()、release() 的滥用。
5. shared_ptr 避免循环引用：将循环引用中的一方改为 weak_ptr。
6. unique_ptr 管理数组时指定 T[]。
7. weak_ptr 访问对象前检查有效性。

总结

从裸指针的风险到智能指针的安全，C++ 的内存管理经历了一次革命性的进化。智能指针通过 RAII 机制，将内存管理的责任从开发者转移到编译器，从根本上解决了内存泄漏、二次释放、野指针等经典问题。在实际开发中，应遵循'能用智能指针就不用裸指针'的原则，合理选择合适的智能指针，让内存管理不再成为痛点。