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

1.5 智能指针的核心使命

智能指针本质是一个'包装器类'，封装裸指针并在析构时自动调用 delete。利用 C++ 对象生命周期规则，对象离开作用域即析构，从而保证内存自动释放。

二、智能指针的三驾马车

C++11 提供了三种核心智能指针，各有适用场景。

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

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

2.1.1 核心原理

• 封装裸指针；
• 禁用拷贝构造和赋值，确保不可复制；
• 支持移动语义，允许所有权转移；
• 析构时调用 delete。

简化实现有助于理解：

template <typename T>
class MyUniquePtr {
private:
    T* ptr;
public:
    ~MyUniquePtr() { delete ptr; }
    MyUniquePtr(const MyUniquePtr&) = delete; // 禁用拷贝
    MyUniquePtr(MyUniquePtr&& other) noexcept : ptr(other.ptr) {
        other.ptr = nullptr;
    }
};

2.1.2 基本使用

推荐使用 make_unique 创建，避免裸指针风险。

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

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

void test_basic() {
    auto up1 = make_unique<Test>(1); // 推荐
    up1->show();
    
    // 移动所有权
    auto up2 = move(up1);
    up2->show();
}

2.1.3 最佳实践

• 优先使用 make_unique；
• 避免滥用 get() 和 release()；
• 管理数组时使用 unique_ptr<T[]>。

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

当多个指针需共享同一块内存时，使用 shared_ptr。它通过引用计数管理资源，最后一个引用消失时才释放。

2.2.1 核心原理：引用计数

每个 shared_ptr 关联一个控制块，存储引用计数。拷贝时计数加 1，析构时减 1。计数为 0 时释放对象和控制块。

2.2.2 基本使用

支持拷贝，但需注意性能开销。

shared_ptr<Test> sp1 = make_shared<Test>(1);
shared_ptr<Test> sp2 = sp1; // 引用计数 +1

2.2.3 循环引用问题

若两个 shared_ptr 互相持有，引用计数永不为 0，导致泄漏。

sp1->sp_self = sp2;
sp2->sp_self = sp1;
// 离开作用域后，对象不会被析构

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

weak_ptr 不拥有对象所有权，仅观察 shared_ptr 管理的对象。它不增加引用计数，常用于解决循环引用。

2.3.1 核心原理

• 仅存储控制块指针；
• 通过 lock() 获取 shared_ptr 才能访问对象；
• 可通过 expired() 检查对象是否存活。

2.3.2 解决循环引用

将循环中的一方改为 weak_ptr。

weak_ptr<Test> wp_self; // 代替 shared_ptr
sp1->wp_self = sp2;
sp2->wp_self = sp1;
// 离开作用域后，引用计数归零，对象正常析构

2.3.3 使用场景

• 解决 shared_ptr 循环引用；
• 观察者模式；
• 缓存场景。

三、进阶技巧

3.1 定制删除器

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

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

3.2 类型转换

智能指针不能直接用 static_cast，需专用函数。

• static_pointer_cast：静态转换；
• dynamic_pointer_cast：动态转换（需多态）；
• const_pointer_cast：去除 const。

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

3.3 性能优化

• 优先用 unique_ptr，无额外开销；
• 用 make_shared 减少内存分配次数；
• 避免不必要的 shared_ptr 拷贝；
• weak_ptr::lock() 返回的 shared_ptr 及时释放。

四、避坑指南与总结

常见错误

1. 循环引用：导致泄漏，改用 weak_ptr。
2. 过期访问：lock() 返回空指针前未检查。
3. 数组管理：unique_ptr<int> 应改为 unique_ptr<int[]>。
4. 裸指针混用：避免将裸指针交给多个智能指针管理。

最佳实践

1. 能用智能指针就不用裸指针；
2. 优先使用 make_shared / make_unique；
3. 不混合使用裸指针和智能指针；
4. shared_ptr 避免循环引用；
5. unique_ptr 管理数组指定 T[]。

总结

从裸指针的'步步惊心'到智能指针的自动化管理，C++ 内存管理经历了革命性进化。智能指针通过 RAII 机制，将责任从开发者转移到编译器，从根本上解决了内存泄漏等问题。在实际开发中，遵循'能⽤智能指针就不用裸指针'的原则，合理选择类型，能让代码更安全、高效。记住，智能指针虽不是银弹，却是 C++ 内存管理最强大的武器。