C++智能指针：从所有权到循环引用

有了这种包装，碰到手动申请的资源，直接丢给智能指针就行了。一旦它离作用域，析构函数自动把活干完。

标准库的几种智能指针

C++ 标准库在 <memory> 头里给了我们几套方案，各有各的用途。

auto_ptr

auto_ptr 是 C++98 的老黄历了。它拷贝时会把资源管理权直接转移给新对象，原对象悬空。这种设计很容易踩坑，一不小心访问原对象就是未定义行为。C++11 之后有了更安全的替代品，别再碰它了。

std::auto_ptr<std::string> ap1(new std::string("xxx"));
// 拷贝后，管理权转移，ap1 已沦为野指针
std::auto_ptr<std::string> ap2(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));

它还支持 operator bool，可以直接放 if 里判断是否持有资源。

shared_ptr

shared_ptr 同样 C++11 问世，支持拷贝和移动，靠引用计数管理共享所有权。一份资源可以同时被多个 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 和上面两类不同，它不参与资源管理，不计入引用计数。存在的唯一理由就是收拾 shared_ptr 循环引用的烂摊子。

两个注意点

库里的智能指针析构时默认用 delete 释放资源。如果你传的不是 new 出来的东西，必须自己提供删除器，否则崩溃。删除器是一个可调用对象，构造时传入即可。

对 new[] 也做了支持：unique_ptr 和 shared_ptr 都特化了数组版本，比如 std::shared_ptr<int[]> sp(new int[10]); 能正确使用 delete[]。

自己动手写几个

搞懂原理最快的方式就是摹写一遍。只要把所有权规则体现在拷贝／移动构造和赋值里就行。构造函数记得加 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 的要点在于引用计数必须多指针共享。通常单独申请一个 int 来存计数。删除器我用 std::function 装着，默认就是 delete。

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) {
            ++(*_pcount);
        }

        void release() {
            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; };
    };
}

循环引用与 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。当这两个 shared_ptr 离开作用域时，计数分别减到 1，谁都不会释放，因为对方还在'等待'。两个节点就这样互相吊着，造成内存泄漏。

把 ListNode 里的 shared_ptr 换成 weak_ptr，问题迎刃而解。weak_ptr 不增加引用计数，循环就此打破。

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 或另一个 weak_ptr 构造。它没有 operator* 和 operator->，因为它不保证资源还在。想安全访问，可以调用 lock()，它会返回一个 shared_ptr：如果资源已释放，返回空；否则返回一个有效的 shared_ptr，同时引用计数加一，确保访问期间资源不会被销毁。另外，expired() 可以检查资源是否已经过期，use_count() 返回关联 shared_ptr 的引用计数。