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引用对象仍指向它，导致悬空指针和您看到的错误。

如果您只需要在父项存在时存在子项，我会考虑将Node更改为只有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;

为什么我在使用shared_ptr时会遇到此运行时异常？

2 个答案: