为什么在使用 shared_ptr 时会出现此运行时异常？

Question

在下面的代码中，我在返回 1 后得到以下运行时异常（可能是内存泄漏）；并在 Node() 的析构函数中。

Unhandled exception at 0x0f9bad4a (msvcp100d.dll) in test.exe: 0xC0000005: Access violation reading location 0xfeeefef2.

自从我使用 smart_ptr 已经有一段时间了，所以我想知道我在这里做错了什么？

#include <vector>
#include <queue>
#include <memory>

#include <iostream>
using namespace std;

class Node;
typedef shared_ptr<Node> SharedNode;

class Node {
    Node* parent;
    vector< SharedNode > children;
    int value;

    //limiting construction
    Node(int a_value):value(a_value),parent(0){}
    Node(const Node &copy); //non-construction-copyable
    Node& operator=(const Node& copy); //non-copyable
public:
    static SharedNode create(int a_value){
        return SharedNode(new Node(a_value));
    }
    SharedNode addChild(SharedNode child){
        child->parent = this;
        children.push_back(child);
        return child;
    }

SharedNode getNode(int searchValue);
};

SharedNode Node::getNode(int searchValue){

    // Breadth First Search
    queue<SharedNode> que;
    que.push(SharedNode(this));

    while(!que.empty()){
        SharedNode node = que.front();
        que.pop();

        if(node->value == searchValue)
            return node;

        vector<SharedNode>::iterator it;
        for(it = node->children.begin(); it != node->children.end(); it++){
            que.push(*it);
        }
    }

    return 0;
}

int main(){
    SharedNode node_ptr = Node::create(5);

    for(int i  = 0; i < 4; ++i)
        node_ptr->addChild(Node::create(i));

    cout << (node_ptr->getNode(-1) != 0 ? "Found" : "Not found");

    return 1;
}

我想我在使用 shared_ptr 时搞砸了，比如：shared_ptr(this)。但是，那是我的猜测。

我在这里做错了什么？

Answer 1

问题出在

que.push(SharedNode(this));

这将创建一个新的共享指针，该指针现在拥有this。然而，由于create() 方法，有另一个共享指针拥有相同的对象。这可能会导致双重删除。

如果你有理由在这种情况下使用共享指针，正确的解决方案是enable_shared_from_this。

首先，把节点定义改成这个。

class Node : public std::enable_shared_from_this<Node> { ...

然后将违规行改为

que.push(this->shared_from_this());

这会导致它返回一个指向对象的 shared_ptr，但它与已经存在的 shared_ptr 共享，而不是两个单独的 shared_ptr 对象。

注意，this->shared_from_this() 的使用是合法的，对象必须由 shared_ptr 拥有。您已经通过静态 create() 方法完成了此操作，但我想确保您了解限制。

编辑：shared_ptr 所有权的简要说明。

当您使用构造函数从原始指针创建shared_ptr 时，它会创建一个引用对象，其中包含指向该对象的指针和引用计数，用于确定有多少shared_ptr 对象指向它.然后将指向此引用对象的指针传递给从原始 shared_ptr 创建的所有副本，引用计数跟踪有多少 shared_ptr 对象引用它。

当您调用shared_ptr(this) 时，共享指针无法知道this 由另一个共享指针拥有，并创建一个新的引用对象。一旦其中一个达到引用计数为零，该对象将被删除，尽管另一个 shared_ptr 引用对象仍指向它，从而导致悬空指针和您看到的错误。

如果您只需要在父节点存在时子节点存在，我会考虑将节点更改为简单地拥有其他节点的std::vector（删除指针）。当最高层节点通过其析构函数被销毁时，它会销毁向量，从而销毁子节点，依此类推。

class Node
{
  // whatever operations you need... 

  std::vector<Node> children;
}

编辑：根据要求...

如果您确实希望让子代比父代更长寿，则必须处理父指针，因为它可能在子代之前被销毁。一种快速的解决方案是确定您是否真的需要父指针，如果不需要则将其删除。

但是，假设你仍然想保留它，你不能在这里使用shared_ptr。如果你这样做了，你将有一个循环依赖，并且两者都不会被自动销毁，这不是你想要的。

这里的解决方案是使用std::weak_ptr。基本上，它与 shared_ptr 引用对象的交互方式不会阻止指向对象的破坏。

class Node
{
private:
   std::weak_ptr<Node> parent;
   // Other constructors.  
   Node(int a_value):value(a_value),parent() {} 
public:
   SharedNode addChild(SharedNode child){
        child->parent = this->shared_from_this(); // Initialize their pointer using
                                                  // your shared pointer
        children.push_back(child);
        return child;
   }
   // This function will return a shared_ptr to nullptr (and will evaluate false) 
   // if you have no parent, or if the parent node has been deleted
   SharedNode getParent()
   {
       return parent.lock();
   }
};

Answer 2

考虑以下代码会发生什么：

Node * dumb_ptr = new Node;
shared_ptr<Node> smart1 = dumb_ptr;
shared_ptr<Node> smart2 = dumb_ptr;

您现在有两个智能指针，它们都认为它们拥有同一个对象。其中一个将删除该对象，另一个将在某个时候尝试使用或删除该已删除对象。解决此问题的方法是始终从另一个智能指针或 new 创建一个智能指针。最好不要使用任何愚蠢的指针——包括this。

shared_ptr<Node> smart1 = new Node;
shared_ptr<Node> smart2 = smart1;