关于std::shared_ptr与std::enable_shared_from_this循环引用导致的问题

最新推荐文章于 2025-05-13 00:00:51 发布

原创最新推荐文章于 2025-05-13 00:00:51 发布 · 2.6k 阅读

4 ·

CC 4.0 BY-SA版权

C++11 专栏收录该内容

6 篇文章

订阅专栏

本文探讨了C++中std::shared_ptr自我引用的问题，包括其在栈对象和堆对象中的表现，分析了引用计数导致的对象无法释放，并提供了解决方案。

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

自从C++11有了std::shared_ptr这样的智能指针，作为C++程序只要将一个堆上的类对象用std::shared_ptr包裹一下就可以做到内存自动释放了。看一个例子：

#include "stdafx.h"
#include <memory>

class A
{
public:
    A()
    {
        m_i = 9;
    }

    ~A()
    {
        m_i = 0;
    }

public:
    int     m_i;

};

int _tmain(int argc, _TCHAR* argv[])
{
    {
        std::shared_ptr<A> spa(new A());
    }
    

    return 0;
}

如下图，上面的代码new出来一个堆对象A，但是出了作用域后，由于std::shared_ptr对象spa的引用计数减为0，会自动调用A的析构函数来释放这块堆内存：

但是假如，我们有一些开发需求中（也可能是前同事遗留下的代码），我们需要在一个类中引用自身，即一个类的一个成员变量是一个std::shared_ptr对象，它引用了类对象自身，这里分为两种情况，第一种情况是类对象是栈对象，第二种情况是类对象是堆对象。

我们先看类对象是栈对象的情形，示例代码如下：

#include "stdafx.h"
#include <memory>

class A : public std::enable_shared_from_this<A>
{
public:
    A()
    {
        m_i = 9;
        //注意:
        //比较好的做法是在构造函数里面调用shared_from_this()给m_SelfPtr赋值
        //但是很遗憾不能这么做,如果写在构造函数里面程序会直接崩溃
    }
    
    ~A()
    {
        m_i = 0;
    }

    void func()
    {
        m_SelfPtr = shared_from_this();
    }

public:
    int                 m_i;
    std::shared_ptr<A>  m_SelfPtr;

};

int _tmain(int argc, _TCHAR* argv[])
{
    {
        A a;
        a.func();
    }
    

    return 0;
}

上面的代码，在调用a.func()时程序会直接崩溃，崩溃的原因是调用shared_from_this()函数里面，看一下崩溃的调用堆栈：

我们来看下崩溃的原因，看下shared_from_this()函数的调用细节：

也就是说shared_from_this()函数内部会先调用shared_ptr的构造函数去构造一个shared_ptr对象，参数是自己的成员变量_Wptr，这是一个std::weak_ptr：

private:
	template<class _Ty1,
		class _Ty2>
		friend void _Do_enable(
			_Ty1 *,
			enable_shared_from_this<_Ty2>*,
			_Ref_count_base *);

	mutable weak_ptr<_Ty> _Wptr;

而shared_ptr的构造函数里面又会调用reset()先释放之前的对象引用，如果这个之前的对象就是_Wptr这个指针去引用，但是现在_Wptr是空的，就抛出一个异常。_Wptr之所以为空，是这个指针引用的对象并没有被任何智能指针所包裹（A的对象a是栈变量）。这就是崩溃的原因。

我们来接着看下A对象是堆对象的情形：

class A : public std::enable_shared_from_this<A>
{
public:
    A()
    {
        m_i = 9;
        //注意:
        //比较好的做法是在构造函数里面调用shared_from_this()给m_SelfPtr赋值
        //但是很遗憾不能这么做,如果写在构造函数里面程序会直接崩溃
    }
    
    ~A()
    {
        m_i = 0;
    }

    void func()
    {
        m_SelfPtr = shared_from_this();
    }

public:
    int                 m_i;
    std::shared_ptr<A>  m_SelfPtr;

};

int _tmain(int argc, _TCHAR* argv[])
{
    {
        std::shared_ptr<A> spa(new A());
        spa->func();
    }
    

    return 0;
}

这次不会崩溃了，但是遗憾的是，这个new出来的A对象的堆内存再也不会释放了（当然程序退出靠操作系统回收不算）。为啥不会释放呢？我们来分析下原因：

要想堆上的A被释放，那么至少需要所有指向A的std::shared_ptr对象都不再引用A，但是A的成员变量只有在A自己被释放的时候才会不再引用A。反过来说，A的成员变量m_SelfPtr等着A对象本身释放，而A作为堆对象释放的条件是所有引用它的的std::shared_ptr释放。这就相互矛盾了。这种情形导致，这样的A对象永远不会被自动释放。我们使用std::weak_ptr来看看最终这个A的引用计数是多少：

#include "stdafx.h"
#include <memory>

class A : public std::enable_shared_from_this<A>
{
public:
    A()
    {
        m_i = 9;
        //注意:
        //比较好的做法是在构造函数里面调用shared_from_this()给m_SelfPtr赋值
        //但是很遗憾不能这么做,如果写在构造函数里面程序会直接崩溃
    }
    
    ~A()
    {
        m_i = 0;
    }

    void func()
    {
        m_SelfPtr = shared_from_this();
    }

public:
    int                 m_i;
    std::shared_ptr<A>  m_SelfPtr;

};

int _tmain(int argc, _TCHAR* argv[])
{
    std::weak_ptr<A> spwa;
    {
        std::shared_ptr<A> spa(new A());
        spa->func();
        spwa = spa;
    }

    printf("spwa usecount: %d\n", spwa.use_count());
    

    return 0;
}

确实和我们分析的一样，这个堆上的A引用计数永远是A了，所以不会被释放了。

那有什么解决方案呢？

我们可以在增加一个成员函数，在不需要A时，主动释放这个智能指针的成员变量引用的对象：

#include "stdafx.h"
#include <memory>

class A : public std::enable_shared_from_this<A>
{
public:
    A()
    {
        m_i = 9;
        //注意:
        //比较好的做法是在构造函数里面调用shared_from_this()给m_SelfPtr赋值
        //但是很遗憾不能这么做,如果写在构造函数里面程序会直接崩溃
    }
    
    ~A()
    {
        m_i = 0;
    }

    void func()
    {
        m_SelfPtr = shared_from_this();
    }

    void release()
    {
        m_SelfPtr.reset();
    }

public:
    int                 m_i;
    std::shared_ptr<A>  m_SelfPtr;

};

int _tmain(int argc, _TCHAR* argv[])
{
    std::weak_ptr<A> spwa;
    {
        std::shared_ptr<A> spa(new A());
        spa->func();
        spa->release();
        spwa = spa;
    }

    printf("spwa usecount: %d\n", spwa.use_count());
    

    return 0;
}

这样，程序就会自动调用A的析构函数来释放自己呢。但是！！！这样人为地增加一个release()函数相当于手工调用了delete，使用智能指针还有什么意义，我们还得人工管理内存释放。

综合下来，这种在对象内部引用自己的智能指针是一种非常不好的设计，个人觉得还是要杜绝这种错误的用法。