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

智能指针的核心使命是将指针生命周期与对象生命周期绑定，在析构函数中自动调用 delete，从而避免上述问题。

智能指针的三驾马车

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

unique_ptr：独占所有权的独行侠

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

原理与实现

底层封装裸指针，禁用拷贝构造和赋值，支持移动语义。我们可以通过简化版理解其逻辑：

template <typename T>
class MyUniquePtr {
private:
    T* ptr;
public:
    explicit MyUniquePtr(T* p = nullptr) : ptr(p) {}
    ~MyUniquePtr() { delete ptr; ptr = nullptr; }
    
    // 禁用拷贝
    MyUniquePtr(const MyUniquePtr&) = delete;
    MyUniquePtr& operator=(const MyUniquePtr&) = delete;
    
    // 支持移动
    MyUniquePtr(MyUniquePtr&& other) noexcept : ptr(other.ptr) {
        other.ptr = nullptr;
    }
    
    T* get() const { return ptr; }
    void reset(T* p = nullptr) { delete ptr; ptr = p; }
};

基本使用

推荐使用 make_unique 创建，更安全。

#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_basic() {
    // 推荐方式
    unique_ptr<Test> up1 = make_unique<Test>(1);
    up1->show();
    
    // 移动语义转移所有权
    unique_ptr<Test> up2 = move(up1);
    // up1 变为 nullptr
    
    // 管理数组需指定类型
    unique_ptr<int[]> arr(new int[5]{1, 2, 3, 4, 5});
}

最佳实践：

• 优先使用 make_unique。
• 容器元素常用 vector<unique_ptr<T>>。
• 管理数组时使用 unique_ptr<T[]>。

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

当多个指针需要共享同一块内存时，shared_ptr 应运而生。它支持共享所有权，通过引用计数控制内存释放。

引用计数原理

每个 shared_ptr 包含数据指针和控制块指针。控制块存储引用计数、弱引用计数等信息。当最后一个 shared_ptr 销毁时，引用计数归零，对象和控制块才会被释放。

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

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

循环引用问题

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

shared_ptr<Test> sp1 = make_shared<Test>(100);
shared_ptr<Test> sp2 = make_shared<Test>(200);
sp1->sp_self = sp2; // 假设成员变量为 shared_ptr
sp2->sp_self = sp1;
// 离开作用域后，引用计数为 1，无法析构

weak_ptr：打破循环的旁观者

weak_ptr 是一种弱引用，不拥有对象所有权，不会增加引用计数。它依赖 shared_ptr 的控制块，用于解决循环引用。

核心用法

不能直接访问对象，需通过 lock() 获取 shared_ptr。

weak_ptr<Test> wp = sp1;
if (auto sp = wp.lock()) {
    sp->show(); // 安全访问
} else {
    cout << "Object destroyed" << endl;
}

场景：

• 解决 shared_ptr 循环引用。
• 观察者模式（观察者持主题弱引用）。
• 缓存场景（对象销毁后缓存失效）。

进阶技巧与性能优化

定制删除器

默认使用 delete 或 delete[]，特殊资源（如文件句柄）需自定义删除器。

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

类型转换

智能指针不支持直接 cast，需使用专用函数：

• static_pointer_cast
• dynamic_pointer_cast（需多态）
• const_pointer_cast

shared_ptr<Base> base = make_shared<Derived>();
auto derived = dynamic_pointer_cast<Derived>(base);

性能优化建议

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

避坑指南与总结

常见错误

• shared_ptr 循环引用未用 weak_ptr 解决。
• weak_ptr 未检查 expired() 或未判断 lock() 返回值。
• 管理数组误用 unique_ptr<T> 而非 unique_ptr<T[]>。
• 混用裸指针与智能指针管理同一内存，导致二次释放。

最佳实践总结

1. 能用智能指针就不用裸指针。
2. 优先使用 make_unique/make_shared。
3. 不混合使用裸指针和智能指针。
4. shared_ptr 避免循环引用，一方改为 weak_ptr。
5. unique_ptr 管理数组时指定 T[]。
6. weak_ptr 访问前检查有效性。

掌握智能指针及其原理，能让代码更安全高效。遵循'能⽤智能指针就不用裸指针'的原则，合理选择类型，让内存管理不再是痛点。