C++ 内存管理核心：智能指针原理与应用

有了这样的封装，遇到手动申请资源时，直接用智能指针接收即可。当智能指针对象离开作用域时，资源会在析构函数中被自动释放。

C++ 标准库中的智能指针

C++ 标准库在 <memory> 头文件中提供了多种智能指针实现，它们各有特点。

auto_ptr

auto_ptr 是 C++98 时代的产物。它的特点是拷贝时会把被拷贝对象的资源管理权转移给拷贝对象。这种设计非常危险，因为它会使原对象变成悬空指针（野指针），稍不注意访问就会报错。C++11 之后已有更安全的替代方案，建议不再使用 auto_ptr。

std::auto_ptr<std::string> ap1(new std::string("xxx"));
// 拷贝后，资源管理权限转移，ap1 悬空
std::auto_ptr<std::string> ap2(ap1);
// 此时若访问 ap1，就会访问野指针，程序可能会挂掉
// std::cout << *ap1 << std::endl;

unique_ptr

unique_ptr 是 C++11 引入的智能指针，它的特点是不支持拷贝，只支持移动语义。如果场景不需要共享所有权，推荐使用它，因为它开销最小且语义明确。

std::unique_ptr<std::string> up1(new std::string("xxx"));
// 不支持拷贝，会报错
// std::unique_ptr<std::string> up2(up1);

// 可以进行移动，但移动后 up1 也会悬空，移动需谨慎
std::unique_ptr<std::string> up3(std::move(up1));

unique_ptr 还支持了 operator bool 的类型转换。如果智能指针对象没有管理资源（为空），则返回 false，否则返回 true。这允许我们直接在 if 语句中判断指针有效性。

shared_ptr

shared_ptr 同样是 C++11 设计的智能指针，它的特点是支持拷贝和移动，底层通过引用计数实现。

一份资源可以同时被多个 shared_ptr 管理。引用计数记录当前有多少个'管理者'。当其中一个 shared_ptr 析构时，不会立即释放资源，而是将引用计数减一。只有当引用计数降为零时，意味着最后一个管理者离开，资源才会被真正释放。这种方式避免了重复释放的问题。

shared_ptr 提供了一个接口 use_count()，用于查询当前指向资源的管理者个数。

std::shared_ptr<std::string> sp1(new std::string("xxx"));
std::shared_ptr<std::string> sp2(sp1);
std::shared_ptr<std::string> sp3(sp1);
std::cout << sp3.use_count() << std::endl;

同样支持 operator bool 类型转换，可用于条件判断。

weak_ptr

weak_ptr 也是 C++11 引入的，但它与上述两种不同。它不支持 RAII 的资源管理功能，不增加引用计数。weak_ptr 的主要作用是解决 shared_ptr 循环引用导致的内存泄漏问题。

特殊说明

库中的智能指针析构时默认使用 delete 进行资源释放。这意味着如果传入的不是 new 出来的资源，析构时会导致崩溃。智能指针支持在构造时提供一个删除器（Deleter），本质上是一个可调用对象，用于自定义资源释放方式。

实际使用中，new[] 也很常见。因此 unique_ptr 和 shared_ptr 都特化了支持数组的版本，例如 std::shared_ptr<int[]> sp(new int[10]); 即可管理数组资源。

智能指针的实现原理

我们可以尝试模拟实现几种智能指针，思路并不复杂，只要遵循它们各自的所有权规则即可。注意 unique_ptr 和 shared_ptr 的构造函数需要使用 explicit 修饰，防止普通指针隐式转换为智能指针对象。

namespace lydly {
    template<class T>
    class auto_ptr {
    public:
        auto_ptr(T* ptr) : _ptr(ptr) {}
        auto_ptr(auto_ptr<T>& ap) : _ptr(ap._ptr) {
            // 管理权转移
            ap._ptr = nullptr;
        }
        ~auto_ptr() {
            if (_ptr) delete _ptr;
        }
        
        auto_ptr<T>& operator=(auto_ptr<T>& ap) {
            if (this != &ap) {
                if (_ptr) delete _ptr;
                _ptr = ap._ptr;
                ap._ptr = nullptr;
            }
            return *this;
        }
        
        T& operator*() { return *_ptr; }
        T* operator->() { return _ptr; }

    private:
        T* _ptr;
    };

    template<class T>
    class unique_ptr {
    public:
        explicit unique_ptr(T* ptr) : _ptr(ptr) {}
        ~unique_ptr() {
            if (_ptr) delete _ptr;
        }

        // 不支持拷贝
        unique_ptr(const unique_ptr<T>& up) = delete;
        unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;

        // 支持移动
        unique_ptr(unique_ptr<T>&& up) : _ptr(up._ptr) {
            up._ptr = nullptr;
        }
        unique_ptr<T>& operator=(unique_ptr<T>&& up) {
            delete _ptr;
            _ptr = up._ptr;
            up._ptr = nullptr;
            return *this;
        }

        T& operator*() { return *_ptr; }
        T* operator->() { return _ptr; }
        operator bool() { return _ptr != nullptr; }

    private:
        T* _ptr;
    };
}

至于 shared_ptr，关键在于设计引用计数机制。指向同一资源的不同智能指针需要共用一个引用计数，通常可以通过额外分配一块内存存储计数来实现。

namespace lydly {
    template<class T>
    class shared_ptr {
    public:
        explicit shared_ptr(T* ptr) : _ptr(ptr), _pcount(new int(1)) {}

        // 自己提供删除器的构造函数
        template<class D>
        shared_ptr(T* ptr, D del) : _ptr(ptr), _pcount(new int(1)), _del(del) {}

        shared_ptr(const shared_ptr<T>& sp) : _ptr(sp._ptr), _pcount(sp._pcount), _del(sp._del) {
            // 拷贝后引用计数 +1
            (*_pcount)++;
        }

        void release() {
            // 先使引用计数 -1，再判断此时是否为 0，为 0 则释放资源
            if (--(*_pcount) == 0) {
                _del(_ptr);
                delete _pcount;
                _ptr = nullptr;
                _pcount = nullptr;
            }
        }

        ~shared_ptr() {
            release();
        }

        shared_ptr<T>& operator=(const shared_ptr<T>& sp) {
            if (_ptr != sp._ptr) {
                release();
                _ptr = sp._ptr;
                _pcount = sp._pcount;
                (*_pcount)++;
                _del = sp._del;
            }
            return *this;
        }

        T& operator*() { return *_ptr; }
        T* operator->() { return _ptr; }
        int use_count() const { return *_pcount; }
        operator bool() { return _ptr != nullptr; }

    private:
        T* _ptr;
        int* _pcount; // 引用计数
        std::function<void(T*)> _del = [](T* ptr){ delete ptr; }; // 删除器，默认提供 delete 版本
    };
}

shared_ptr 的循环引用问题与 weak_ptr 的使用

shared_ptr 在大部分情况下管理资源非常合适，但存在一种特殊情况：循环引用。

struct ListNode {
    int val;
    std::shared_ptr<ListNode> next = nullptr;
    std::shared_ptr<ListNode> prev = nullptr;
};

std::shared_ptr<ListNode> n1(new ListNode);
std::shared_ptr<ListNode> n2(new ListNode);
n1->next = n2;
n2->prev = n1;

经过上述代码，n1 和 n2 互相持有对方的 shared_ptr。当 n1 析构时，第一个资源的引用计数减为 1，资源不释放；当 n2 析构时，第二个资源的引用计数减为 1，资源也不释放。这就形成了一个死锁局面：第一个资源依赖第二个释放，第二个依赖第一个释放，谁都无法释放，导致内存泄漏。

此时就需要 weak_ptr 出手。将 ListNode 中的 shared_ptr 改为 weak_ptr 就能解决这个问题。 weak_ptr 不会增加引用计数，next 和 prev 就不参与资源管理，成功打破循环引用。

struct ListNode {
    int val;
    std::weak_ptr<ListNode> next = nullptr;
    std::weak_ptr<ListNode> prev = nullptr;
};

std::shared_ptr<ListNode> n1(new ListNode);
std::shared_ptr<ListNode> n2(new ListNode);
n1->next = n2;
n2->prev = n1;

weak_ptr 不支持直接绑定到裸资源，只能绑定到 shared_ptr，且不增加 shared_ptr 的引用计数。由于它不参与资源管理，也没有重载 operator* 和 operator->。如果它绑定的 shared_ptr 已经释放了资源，去访问资源就是危险的。

• weak_ptr 有一个接口 expired() 检查它指向的资源是否过期。
• weak_ptr 的 use_count() 也可获取 shared_ptr 的引用计数。
• weak_ptr 想访问资源时，可以调用 lock() 返回一个管理资源的 shared_ptr（也会使引用计数 +1）。如果资源已经被释放，则返回的 shared_ptr 是空对象；如果资源没有释放，则通过返回的 shared_ptr 访问资源是安全的。