C++ 智能指针原理与核心实现解析

auto_ptr 的局限性

如果在当前作用域外还需要使用该指针怎么办？普通的封装无法让指针'逃出'作用域，因为析构时会销毁底层资源。我们需要一种机制让其他对象继承对底层指针的管理权。

标准库早期的 auto_ptr 采用了这种所有权转移的方式：拷贝或赋值时，原对象会放弃所有权并置空。

template<class T>
class AutoPtr {
    using Ptr = T*;
    using Ref = T&;
public:
    explicit AutoPtr(T* ptr = nullptr) : _ptr(ptr) {}
    ~AutoPtr() noexcept {
        if (_ptr) {
            cout << "指针内存释放" << endl;
            delete _ptr;
        }
    }
    // 拷贝构造：转移所有权
    AutoPtr(AutoPtr& x) {
        _ptr = x._ptr;
        x._ptr = nullptr;
    }
    // 赋值运算：转移所有权
    AutoPtr& operator=(AutoPtr& x) noexcept {
        if (&x != this) {
            _ptr = x._ptr;
            x._ptr = nullptr;
        }
        return *this;
    }
    Ref operator*() const {
        if (!_ptr) throw runtime_error("空指针");
        return *_ptr;
    }
    Ptr operator->() const noexcept { return _ptr; }
    explicit operator bool() const noexcept { return _ptr != nullptr; }
private:
    Ptr _ptr = nullptr;
};

测试发现，赋值后原指针确实变空了。但这种剥夺式赋值在实际开发中极易导致悬空指针问题，因此在 C++11 中被弃用，C++17 彻底移除。

unique_ptr：独占所有权

很多时候，我们只希望某个堆内存被一个对象管控。unique_ptr 应运而生，它禁止拷贝，仅支持移动语义。

template<class T>
class UniquePtr {
    using Ptr = T*;
    using Ref = T&;
public:
    explicit UniquePtr(T* ptr = nullptr) : _ptr(ptr) {}
    ~UniquePtr() noexcept {
        if (_ptr) {
            cout << "指针内存释放" << endl;
            delete _ptr;
        }
    }
    // 禁止拷贝
    UniquePtr(const UniquePtr&) noexcept = delete;
    UniquePtr& operator=(const UniquePtr&) noexcept = delete;
    // 支持移动
    UniquePtr(UniquePtr&& x) noexcept {
        if (this != &x) swap(x);
    }
    UniquePtr& operator=(UniquePtr&& x) noexcept {
        if (this != &x) swap(x);
        return *this;
    }
    Ref operator*() const {
        if (!_ptr) throw runtime_error("空指针");
        return *_ptr;
    }
    Ptr operator->() const noexcept { return _ptr; }
    Ptr get() const noexcept { return _ptr; }
    Ptr release() noexcept {
        Ptr ret = _ptr;
        _ptr = nullptr;
        return ret;
    }
    void reset(Ptr ptr = nullptr) noexcept {
        if (_ptr) delete _ptr;
        _ptr = ptr;
    }
    void swap(UniquePtr& x) noexcept {
        std::swap(_ptr, x._ptr);
    }
private:
    Ptr _ptr = nullptr;
};

shared_ptr：共享所有权

auto_ptr 的转移方式并不符合所有需求，同一块地址往往需要被多个指针共同维护。shared_ptr 通过引用计数来实现这一点：拷贝时不转移指针，而是增加计数；析构时减少计数，归零则释放内存。

template<class T>
class SharedPtr {
    using Ptr = T*;
    using Ref = T&;
public:
    explicit SharedPtr(T* ptr = nullptr)
        : _ptr(ptr), _pcount(ptr ? new size_t(1) : nullptr) {}
    
    ~SharedPtr() noexcept {
        if (_ptr && !(*--_pcount)) {
            cout << "指针内存释放" << endl;
            delete _ptr;
            delete _pcount;
        }
    }
    
    SharedPtr(const SharedPtr& x) noexcept {
        _ptr = x._ptr;
        _pcount = x._pcount;
        if (_ptr) ++*_pcount;
    }
    
    SharedPtr& operator=(const SharedPtr& x) noexcept {
        if (&x != this) {
            SharedPtr temp(x);
            swap(temp);
        }
        return *this;
    }
    
    Ref operator*() const {
        if (!_ptr) throw runtime_error("空指针");
        return *_ptr;
    }
    Ptr operator->() const noexcept { return _ptr; }
    Ptr get() const noexcept { return _ptr; }
    size_t use_count() const noexcept {
        if (!_ptr) return 0;
        return *_pcount;
    }
private:
    void swap(SharedPtr& x) noexcept {
        std::swap(_ptr, x._ptr);
        std::swap(_pcount, x._pcount);
    }
    Ptr _ptr = nullptr;
    size_t* _pcount = nullptr;
};

多线程安全

如果多个线程同时访问同一个 shared_ptr，引用计数的增减必须是原子操作。我们可以引入 <atomic> 来保证线程安全。

#include <atomic>
// ... 修改 _pcount 类型为 atomic<size_t>* ...
explicit SharedPtr(T* ptr = nullptr)
    : _ptr(ptr), _pcount(ptr ? new atomic<size_t>(1) : nullptr) {}

~SharedPtr() noexcept {
    if (_ptr && !(_pcount && --*_pcount == 0)) {
        cout << "指针内存释放" << endl;
        delete _ptr;
        delete _pcount;
    }
}
// ... 其余部分类似 ...

weak_ptr：打破循环引用

在使用 shared_ptr 构建双向链表等结构时，容易出现循环引用，导致引用计数永远无法归零，造成内存泄露。

template<class T>
struct ListNode {
    ListNode(const T& val) : _val(val) {}
    SharedPtr<ListNode<T>> _l, _r;
    T _val;
};

int main() {
    SharedPtr<ListNode<int>> ln1(new ListNode(1)), ln2(new ListNode(1));
    ln1->_r = ln2;
    ln2->_l = ln1;
    return 0;
}

这种情况下，ln1 和 ln2 互相持有对方的强引用，即使离开作用域，计数也不会降为 0。解决之道是使用 weak_ptr，它只观察而不增加引用计数。

template<class T>
class WeakPtr {
    using Ptr = T*;
    using Ref = T&;
public:
    explicit WeakPtr(const SharedPtr<T>& sp = SharedPtr<T>()) : _ptr(sp.get()) {}
    
    WeakPtr(const WeakPtr& x) noexcept {
        _ptr = x._ptr;
    }
    
    Ref operator*() const {
        if (!_ptr) throw runtime_error("空指针");
        return *_ptr;
    }
    Ptr operator->() const noexcept { return _ptr; }
    Ptr get() const noexcept { return _ptr; }
private:
    Ptr _ptr = nullptr;
};

通过将其中一个成员改为 WeakPtr，即可打破循环，使内存正常回收。

删除器定制

上述实现主要针对单个对象。如果使用 new[] 分配数组，直接 delete 会导致未定义行为。我们需要自定义删除器。

// 仿函数方式
struct Del {
    void operator()(int* p) {
        cout << "仿函数删除器" << endl;
        delete[] p;
    }
};
std::shared_ptr<int> s(new int, Del());

// Lambda 表达式方式
auto del_ = [](int* p) {
    cout << "Lambda 删除器" << endl;
    delete[] p;
};
std::shared_ptr<int> ls(new int, del_);

对于 unique_ptr，由于 lambda 没有默认构造函数，需要显式指定模板参数类型。

底层控制块

工程级的 shared_ptr 和 weak_ptr 并非简单的指针复制。它们通常共享一个控制块（Control Block），其中包含强引用计数、弱引用计数以及原始指针。weak_ptr 持有的是指向控制块的指针，而非原始数据指针。这样即使原始数据被释放，控制块依然存在，直到弱引用也全部消失。这避免了 weak_ptr 访问已释放内存的风险。

具体实现涉及复杂的内存同步机制，此处不再展开代码细节，但理解这一设计有助于掌握智能指针的本质。