C++ 智能指针详解：从需求到实现原理

有了这样的智能指针类，在遇到手动申请资源时就可以用一个智能指针来接受了，当智能指针生命周期结束时，资源也会在调用的析构函数中释放。

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

C++ 标准库也有自己的智能指针，在 <memory> 这个头文件下。智能指针有很多种，有各自不同的特点。

1. 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;

2. unique_ptr

unique_ptr 是 C++11 设计出的一种智能指针，它的特点是不支持拷贝，只支持 move 移动。如果是不需要拷贝的场景就很推荐使用它。

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 等语句判断是否为空。

3. shared_ptr

shared_ptr 是 C++11 设计出的一种智能指针，它的特点是支持拷贝，也支持移动。底层是用引用计数的方式实现的。

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;

shared_ptr 还支持了 operator bool 的类型转换，如果智能指针对象是一个空对象（没有管理资源），则返回 false，否则返回 true。所以我们可以把智能指针给 if 等语句判断是否为空。

4. weak_ptr

weak_ptr 也是 C++11 设计出的一种智能指针，它和上面两种很不一样，它不支持 RAII 的设计思路，它不是用于直接管理资源的。weak_ptr 的作用只在于解决 shared_ptr 的一个循环引用导致的内存泄漏问题。具体我们下文再讲。

5. 特殊说明

库中的智能指针析构时默认使用 delete 进行资源释放，这意味着如果不是 new 出来的资源，智能指针析构时就会崩溃。智能指针其实支持在构造时提供一个删除器，本质是一个可调用对象，用于自定义我们想要的资源释放方式。给了定制的删除器，智能指针析构时就会调用删除器去释放资源。但是 unique_ptr 和 shared_ptr 的构造时提供删除器的格式还不太一样，也是设计上的一个小缺点了。

实际使用中，除了 new，new[] 也是经常使用的。所以 unique_ptr 和 shared_ptr 都特化了一种支持 new[] 的版本，使用如 std::shared_ptr<int[]> sp(new int[10]); 这样，就可以管理 new[] 的资源了。

四、智能指针的实现原理

我们来模拟实现一下几种智能指针，其实思路很简单，只要遵循它们的特点就好。注意 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;
};
} // namespace lydly

至于 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 版本
};
} // namespace lydly

五、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 的 prev 指向一块资源，n2、n1 的 next 指向一块资源。

这种场景中，n1、n2 要怎么进行析构呢？ 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 的引用计数。weak_ptr 也没有重载 operator* 和 operator-> 等，因为他不参与资源管理，如果他绑定的 shared_ptr 已经释放了资源，那么他去访问资源就是很危险的。

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