包含指向自身的智能指针的对象，在对象超出范围之前不会重置

Question

运行进入这个错误，其中 class 包含一个指向自身的指针——它指向同一个实例。这是包含该问题的最小代码片段...

class Node
{
public:
    Node()
    {
        std::cout << "constructor" << std::endl;
    }

    ~Node()
    {
        std::cout << "destructor" << std::endl;
    }

    void storeChild(boost::shared_ptr<Node> ptr)
    {
        m_ptr = ptr;
    }

private: 
    boost::shared_ptr<Node> m_ptr;
};

int main()
{
    boost::shared_ptr<Node> bc_ptr(new Node());
    bc_ptr->storeChild(bc_ptr); // this line is the bug 
    return 0;
}

我的问题是： 1. Node 对象是否被删除？我知道智能指针应该管理这些东西，所以我们不必删除。但看起来使用 storeChild 传递到 class 的引用从未被重置。这是否意味着我将发生内存泄漏？ 2. 有没有办法使用智能指针来防止这种情况发生？很明显， storeChild 方法应该被赋予一个指向不同节点的指针，但是你如何防止这种情况发生呢？

如果我运行这个程序，析构函数永远不会被调用。

Answer 1

是的，这是内存泄漏，因为 Node 中的共享指针永远不会被删除。考虑：

#include <iostream>
#include <memory>

class Node {
    std::shared_ptr<Node> m_ptr;

public:
    Node() { std::cout << "constructor\n"; }
    ~Node() { std::cout << "destructor\n"; }
    void storeChild(std::shared_ptr<Node> ptr) { m_ptr = ptr; }
    long use_count() { return m_ptr.use_count(); }
};

int main() {   
    Node* n = new Node;
    {
        std::shared_ptr<Node> bc_ptr(n);
        bc_ptr->storeChild(bc_ptr); // this line is the bug

        std::cout << n->use_count() << "\n";     // prints 2
    }
    std::cout << n->use_count() << "\n";         // prints 1

    // the Node pointed to by n is leaked
}

如果你这样做可能会更明显:

#include <iostream>
#include <memory>

class Node {
    std::shared_ptr<Node> m_ptr;

public:
    Node() : m_ptr(this) { std::cout << "constructor\n"; }
    ~Node() { std::cout << "destructor\n"; }
};

int main() {
    new Node;
}

如果你尝试：

int main() {
    delete new Node;
}

Node 析构函数将被调用两次。首先由您的 delete 删除，然后由 shared_ptr 删除。

如果可能以循环所有权结束，那么防止它可能会很棘手，例如：A->B->C->A ...如果有风险，您可能应该使用 std::weak_ptr。

包含指向自身的智能指针的对象，在对象超出范围之前不会重置

object containing smart pointer to itself that isn't reset before object goes out of scope

c++

pointers

shared-ptr