方法超出范围后是否应该删除引用的 std::shared_ptr ？

Question

我正在学习智能指针，学习它比在堆上实现一个简单的结构（如链表）更好。

我创建了一个链表结构如下...

// linked list node definition
#ifndef __LINKED_LIST_NODE_H
#define __LINKED_LIST_NODE_H

class LinkedListNode {
    friend class LinkedList;
public:
    int                 m_value;
    LinkedListNode *    m_pNext;
public:
    LinkedListNode();
    LinkedListNode(int);
    LinkedListNode(const LinkedListNode &);
    ~LinkedListNode();
};

#endif

// linked list definition
#ifndef __LINKED_LIST_H
#define __LINKED_LIST_H

class LinkedList {
    LinkedListNode * m_pHead;
    LinkedListNode * m_pTail;
public:
    LinkedList();
    LinkedList(int);
    LinkedList(const LinkedList &);
    ~LinkedList();
    void PrintList() const;
    void AddItem(int);
    void RemoveItem(int);
    LinkedListNode * FindNode(int) const;
    LinkedListNode * FindMin() const;
    LinkedListNode * FindMax() const;
};

#endif

这里是 LinkedListNode 和 LinkedList 类的必要方法（构造函数和析构函数），看看它的样子（IIRC 这些应该是正确的）...

// list node
LinkedListNode::LinkedListNode()
{
    m_value = 0;
    m_pNext = nullptr;
}

LinkedListNode::LinkedListNode(int value)
{
    m_value = value;
    m_pNext = nullptr;
}

LinkedListNode::LinkedListNode(const LinkedListNode & copyNode)
{
    m_value = copyNode.m_value;
    m_pNext = copyNode.m_pNext;
}

LinkedListNode::~LinkedListNode()
{
    // not needed, no dynamic allocation
}


// linked list
LinkedList::LinkedList()
{
    m_pHead = nullptr;
    m_pTail = m_pHead;
}

LinkedList::LinkedList(int value)
{
    std::shared_ptr<LinkedListNode>newNode{ new LinkedListNode(value) };
    m_pHead = newNode.get();
    m_pHead->m_pNext = nullptr;
    m_pTail = m_pHead;
}

LinkedList::LinkedList(const LinkedList & copyList)
{
    if (copyList.m_pHead == nullptr)
    {
        m_pHead = nullptr;
        m_pTail = m_pHead;
    }
    else
    {
        std::shared_ptr<LinkedListNode>NodeResource{ new LinkedListNode(*copyList.m_pHead) };

        LinkedListNode * tempNode = NodeResource.get();

        m_pHead = tempNode;

        while (tempNode->m_pNext != nullptr)
        {           
            std::shared_ptr<LinkedListNode>NodeResourceNext{ new LinkedListNode(*tempNode->m_pNext) };
            tempNode->m_pNext = NodeResourceNext.get();
            tempNode = NodeResourceNext.get();
        }

        m_pTail = tempNode;
    }
}

LinkedList::~LinkedList()
{
    // not needed, allocating using smart pointers
}

现在，LinkedList 类包含 AddItem 方法，其主体是这样的：

void LinkedList::AddItem(int value)
{
    std::shared_ptr<LinkedListNode>newNode{ new LinkedListNode(value) };

    if (m_pHead == nullptr) // linked list is empty
    {
        m_pHead = newNode.get();
        m_pTail = newNode.get();
    }
    else
    {
        m_pTail->m_pNext = newNode.get();
        m_pTail = newNode.get();
    }
}

我不知道为什么，但是当我尝试将一个项目添加到我的链表时，当你超出该方法的范围时，似乎 newNode 变量被删除了。

这是我尝试调试程序时的样子...

首先我们从空链表开始

然后在 AddItem 函数中，我得到以下结果（看起来 m_pHead 和 m_pTail 正确地指向堆上新创建的 newNode。

但是当 AddItem() 方法超出范围时，这就是我剩下的

我想，一旦没有引用指针，std::share_ptr 就会被删除。在我的例子中，newNode 被两个指针 m_pHead 和 m_pTail 引用。离开 AddItem() 方法时它真的被删除了，还是我的代码中存在我没有发现的缺陷？

非常感谢你们的意见，伙计们。

Answer 1

您的问题太长了，但我看到您似乎没有以适当的方式使用std::shared_ptr。例如，

LinkedList::LinkedList(int value)
{
    std::shared_ptr<LinkedListNode>newNode{ new LinkedListNode(value) };
    m_pHead = newNode.get();
    m_pHead->m_pNext = nullptr;
    m_pTail = m_pHead;
}   // <-- call of std::shared_ptr::~std::shared_ptr

newNode 将在函数体的末尾被销毁。然后，这还将删除共享指针的对象（恰好在一个std::shared_ptr 之间），从而使m_pHead 留下一个悬空指针。

shared_ptr 的基本思想是共享某些资源的所有权，只要任何共享所有者还活着，那么资源也是如此：资源是当最后一个所有者死亡时删除。

在绝大多数好的代码中，资源归某些对象所有，即共享所有权是一种相当罕见和小众的情况。在简单的链表实现中绝对不需要它。

---

链表的一种可能的所有权模型是每个节点都拥有下一个节点。那么你会有

template<typename T> class list;
template<typename T>
class node {
  friend class list<T>;
  T m_data;
  unique_ptr<node> m_next;
  explicit node(T const&value)
  : m_data(value) {}
  node(T const&value, unique_ptr<node>&&n)
  : m_data(value), m_next(n) {}
public:
  node*next() { return m_next.get(); }
  const node*next() const { return m_next.get(); }
};

template<typename T>
class list {
  typedef node<T> node_type;
  unique_ptr<node_type> m_head;
  node_type            *m_tail;
  ~list() {}  // destructor of m_head destroys all nodes recursively
  explicit list(T const&value)
  : m_head(new node_type(value)), m_tail(m_head.get()) {}
  void push(T const&value)
  {
    // move the existing m_head to be m_next of the new node,
    // which in turn becomes the new m_head. m_tail is unaffected.
    m_head = new node_type(value,std::move(m_head));
  }
};

但是，您必须小心如何实现插入和切片等。

Answer 2

您正在将 newNode.get() 分配给您的 LinkedListNode 的原始指针 (LinkedListNode*) 成员。

这是不正确的，因为shared_ptr（至少在这种情况下）拥有底层指针。当它超出范围时，相关的内存会被释放，但您的 LinkedListNode 仍然有以前分配的内存的成员。

您可能应该更改LinkedListNode 的定义，使其LinkedListNode* 成员改为shared_ptr<LinkedListNode>，确保只要您的实例存在，就会引用底层内存。