3

在下面的代码中，我在 return 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)。但是，那是我的猜测。

我在这里做错了什么？

4

2 回答 2

6

问题来自

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使用构造函数从原始指针创建 a 时，它会创建一个引用对象，其中包含指向该对象的指针和引用计数，该引用计数用于确定有多少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();
   }
};
于 2012-07-27T19:15:06.360 回答
4

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

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;
于 2012-07-27T19:01:22.980 回答