智能指针循环引用问题

智能指针循环引用

循环引用简单来说就是：两个对象互相使用一个shared_ptr成员变量指向对方，这会造成循环引用。导致引用计数失效，内存无法释放。

#include <iostream>
#include <memory>

class CB;
class CA
{
public:
	CA()
    {
		std::cout << "CA()" << std::endl;
    }
    ~CA()
    {
		std::cout << "~CA()" << std::endl;
    }
    void set_ptr(std::shared_ptr<CB>& ptr)
    {
		m_ptr_b = ptr;
    }
private:
    std::shared_ptr<CB> m_ptr_b;
};

class CB
{
public:
    CB()
    {
		std::cout << "CB()" << std::endl;
    }
    ~CB()
    {
		std::cout << "~CB()" << std::endl;
    }
    void set_ptr(std::shared_ptr<CA>& ptr)
    {
		m_ptr_a = ptr;
    }
private:
    std::shared_ptr<CA> m_ptr_a;
};

int main()
{
	std::shared_ptr<CA> ptr_a(new CA());
    std::shared_ptr<CB> ptr_b(new CB());
    
    ptr_a->set_ptr(ptr_b);
    ptr_b->set_ptr(ptr_a);
    std::cout << ptr_a.use_count() << " " << ptr_b.use_count() << std::endl;
	return 0;
}
/*
CA()
CB()
2 2
*/

既然析构函数没有调用，就说明ptr_a和ptr_b两个变量的引用计数都不是0。

分析一下引用情况
在这里插入图片描述

起初定义完ptr_a和ptr_b时，只有1，3两条引用，即ptr_a指向CA对象，ptr_b指向CB对象。然后调用函数set_ptr()后又增加了2，4两条引用，即CB对象中的m_ptr_a成员变量指向CA对象，CA对象中的m_ptr_b成员变量指向CB对象。

这个时候，指向CA对象的有两个，指向CB对象的也有两个。当main函数运行结束时，对象ptr_a和ptr_b被销毁，也就是1，3两条引用会被断开，2，4两条引用依然存在，每一个的引用计数都不为0，结果就导致其指向的内部对象无法析构，造成内存泄漏。

循环引用解决方法：weak_ptr

循环引用：对被调用的析构函数没有被调用，从而出现了内存泄露。

weak_ptr对被shared_ptr管理的对象存在非拥有性引用，在访问所引用的对象前必须先转化为shared_ptr；
weak_ptr用来打断shared_ptr所管理对象的循环引用问题，若这种环被孤立（没有指向环中的外部共享指针），shared_ptr引用计数无法抵达0，内存被泄露；令环中的指针之一为弱指针可以避免该情况。
weak_ptr用来表示临时所有权的概念。当某个对象只有存在时才需要被访问，而且随时可能被他人删除，可以用weak_ptr跟踪该对象；需要获得所有权时将其转化为shared_ptr，此时如果原来的shared_ptr被销毁，则该对象的生命周期被延长到这个临时的shared_ptr同样被销毁。

#include <iostream>
#include <memory>

class CB;
class CA
{
public:
	CA()
    {
		std::cout << "CA()" << std::endl;
    }
    ~CA()
    {
		std::cout << "~CA()" << std::endl;
    }
    void set_ptr(std::shared_ptr<CB>& ptr)
    {
		m_ptr_b = ptr;
    }
private:
    std::shared_ptr<CB> m_ptr_b;
};

class CB
{
public:
    CB()
    {
        std::cout << "CB()" << std::endl;
    }
    ~CB()
    {
        std::cout << "~CB()" << std::endl;
    }
    void set_ptr(std::shared_ptr<CA>& ptr)
    {
        m_ptr_a = ptr;
    }
private:
    std::weak_ptr<CA> m_ptr_a;
};

int main()
{
	std::shared_ptr<CA> ptr_a(new CA());
    std::shared_ptr<CB> ptr_b(new CB());
    
    ptr_a->set_ptr(ptr_b);
    ptr_b->set_ptr(ptr_a);
    std::cout << ptr_a.use_count() << " " << ptr_b.use_count() << std::endl;
	return 0;
}
/*
CA()
CB()
1 2
~CA()
~CB()
*/

在这里插入图片描述

流程与上一例子大体相似，但是不同的是4这条引用是通过weak_ptr建立的，并不会增加引用计数。也就是说，CA的对象只有一个引用计数，而CB的对象只有两个引用计数，当main函数返回时，对象ptr_a和ptr_b被销毁，也就是1，3两条引用会被断开，此时CA对象的引用计数会减为0，对象被销毁，进而解决了引用成环的问题。