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

Question

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

test.exe 中 0x0f9bad4a (msvcp100d.dll) 处的未处理异常:0xC0000005:读取位置 0xfeeeef2 的访问冲突。

自从我使用 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。其他节点(删除指针)。当最高级别的节点通过其析构函数被销毁时，它将销毁 vector，这会销毁子节点，依此类推。

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

  std::vector<Node> children;
}

编辑:按要求...

如果您有一个用例，您确实想让 child 比 parent 活得更久，您将不得不处理父指针，因为它可能会在 child 之前被销毁。一种快速解决方案是确定您是否真的需要父指针，如果不需要，则将其删除。

但是，假设您仍想保留它，则不能使用 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();
   }
};