从造轮子做起： shared_ptr

最新推荐文章于 2025-07-29 12:00:00 发布

原创最新推荐文章于 2025-07-29 12:00:00 发布 · 324 阅读

0 ·

CC 4.0 BY-SA版权

C++ 专栏收录该内容

10 篇文章

订阅专栏

本文探讨了C++中智能指针shared_ptr的工作原理及其在处理拷贝构造与赋值运算时采用的引用计数方式。同时，文章深入分析了shared_ptr在面对循环引用问题时的局限性，并介绍了如何使用weak_ptr来解决这一问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

由于 auto_ptr 与 scoped_ptr 都有一些弊端，所以 shared_ptr 出现了。它采用了引用计数的方式来处理拷贝构造与赋值运算。

template <typename T>
class SharedPtr {
public:
    SharedPtr(T* ptr)
        :_ptr(ptr) {
        _count = new size_t(0);
        ++*_count;
    }

    SharedPtr(SharedPtr& s) {
        _ptr = s._ptr;
        _count = s._count;
        ++*_count;
    }

    SharedPtr& operator=(const SharedPtr& s) {
        if (this == &s)
            return;

        if (_ptr != NULL) {
            if (--*_count) {
                delete _count;
                delete _ptr;
                _count = nullptr;
                _ptr = nullptr;
            }
        }
        _ptr = s._ptr;
        _count = s._count;
        ++*_count;
    }

    T* operator->() {
        return _ptr;
    }

    T& operator*() {
        return *_ptr;
    }

    ~SharedPtr() {
        if (_ptr == nullptr)
            return;
        if (!--*count) {
            delete _count;
            delete _ptr;
            _count = nullptr;
            _ptr = nullptr;
        }
    }

private:
    T* _ptr;
    size_t* _count;
};

template <typename T>
class SharedArray {
public:
    SharedArray(T* ptr)
        :_ptr(ptr) {
        _count = new size(0);
        ++*_count;
    }

    SharedArray(const SharedArray& s) {
        _ptr = s._ptr;
        _count = s._count;
        ++*_count;
    }

    SharedArray& operator=(const SharedArray& s) {
        if (this == &s)
            return;

        if (_ptr != nullptr) {
            if (!--*_count) {
                delete _ptr;
                delete _count;
                _ptr = nullptr;
                _count = nullptr;
            }
        }
        _ptr = s._ptr;
        _count = s._count;
        ++*_count;
    }

    T* operator->() {
        return _ptr;
    }

    T& operator*() {
        return *_ptr;
    }

    T& operator[](size_t pos) {
        return _ptr[pos];
    }

    ~SharedArray() {
        if (_ptr == nullptr)
            return;

        if (!--*_count) {
            delete _ptr;
            delete _count;
            _ptr == nullptr;
            _count = nullptr;
        }
    }

private:
    T* _ptr;
    size_t* _count;
};

这里要提一下，由于 shared_ptr 采用引用计数来处理的赋值运算。在某些情况下会出现一些问题。比如：

struct ListNode {
    ListNode() = default;
    shared_ptr<ListNode> _prev;
    shared_ptr<ListNode> _next;
    // weak_ptr<ListNode> _prev;
    // weak_ptr<ListNode> _next;
    ~ListNode() = default;
};

void fun() {
    shared_ptr<ListNode> p1(new ListNode());
    shared_ptr<ListNode> p2(new ListNode());

    p1->_next = p2;
    p2->_prev = p1;
}