什么应该在类的析构函数中删除

Question

自从我完成了所有c ++编码以来，已经有一段时间了，我只是想知道基本链接列表中的哪些变量应该在析构函数中删除，但是不幸的是，目前我无法参考我的c ++手册。 链接列表类如下所示：

#include <string>
#include <vector>

class Node
{
    Node *next;
    string sName;
    vector<char> cvStuff;

    Node(string _s, int _i)
    {
        next = nullptr;
        sName = _s;

        for (int i = 0; i < _i; i++)
        {
            cvStuff.insert(cvStuff.end(), '_');
        }
    }

    ~Node()
    {
         //since sName is assigned during runtime do I delete?
         //same for cvStuff?
    }
};

我也很好奇，如果我在析构函数中打电话给我

delete next;

那会去链接列表的下一个节点并删除该节点，从而从那一点递归地删除整个列表吗？ 另外，如果是这种情况，并且出于某种原因我选择实施该方法，那么我是否必须在删除它之前检查next是否为nullptr还是不会有所作为？

谢谢。

Answer 1

理想情况下，什么都std::smart_ptr<> ：使用智能指针： std::unique_ptr<> ， std::smart_ptr<> ， boost::scoped_ptr<>等。

否则，您将删除拥有的本机指针。 next拥有？

• 您打算删除列表中间的内容吗？ 如果是，则无法在析构函数中删除。
• 你打算分享尾巴吗？ 如果是，则需要引用计数的智能指针。

可以删除nullptr（不执行任何操作）。 在该示例中，您不应删除sName和cvStuff，因为它们是作用域的，因此会被自动销毁。

另外，如果这将是一个可能会变得很大的列表，则您可能需要手动销毁并重新分配*next 。 这是因为您不想通过递归耗尽堆栈空间。

此外，我建议将其分离为List ，即数据结构和ListNode ，即元素。 您的问题实际上表明了这种歧义，即您不知道要删除析构函数中的ListNode还是List 。 分离它们可以解决此问题。

Answer 2

具有自动生存期的对象在超出范围时会调用其析构函数：

{  // scope
    std::string s;
}  // end scope -> s.~string()

动态对象（与new一起分配）没有调用它的析构函数，除非在其上调用了delete 。

对于成员变量，范围是对象的生存期。

struct S {
    std::string str_;
    char* p_;
};

int main() {  // scope
    {  // scope
        S s;
    }  // end scope -> s.~S() -> str_.~string()
}

注意，上面的代码p_并没有什么特别的事情：它是一个简单的标量类型的指针，因此代码不会对其自动执行任何操作。

因此，在列表类中，您唯一需要担心的就是next成员：您需要确定它是否是“拥有”指针。 如果它是“拥有”指针，则必须在析构函数中的对象上调用delete 。

另外，您可以利用“ RAII”（资源获取是初始化）并使用一个对象包装指针并提供一个析构函数，该析构函数将为您调用delete ：

{  // scope
    std::unique_ptr<Node> ptr = std::make_unique<Node>(args);
}  // end scope -> ptr.~unique_ptr() -> delete -> ~Node()

unique_ptr是一个纯粹拥有的指针，另一个选择可能是shared_ptr ，它使用引用计数，以便仅当对象没有剩余的shared_ptr时，才delete基础对象。

例如，如果您将Node的实际地址保留在其他位置，则可以将next指针视为非所有者指针：

std::vector<Node> nodes;
populate(nodes);

list.insert(&nodes[0]);
list.insert(&nodes[1]);
// ...

在上述情况下，向量拥有节点，您绝对不应该在Node析构函数中调用delete ，因为Node不是您要删除的。

list.insert(new Node(0));
list.insert(new Node(1));

在这里，列表/节点是唯一具有指向节点的指针的东西，因此在此用例中，我们需要Node::~Node调用delete，否则会发生泄漏。

Answer 3

基本上你应该

delete next 

这就是您应该做的：

• string和vector对象具有自己的析构函数，由于该对象被破坏， 因此将调用它们 。

• 删除空指针不是问题 ，因此您甚至不必检查。

• 如果next不是一个空指针，它将根据需要继续调用下一个节点的析构函数。

只需删除它就可以了。

Answer 4

您的类析构函数将被调用（为空），然后调用成员对象析构函数。

如果member不是对象，则不会调用析构函数。

在您的示例中：

- List *next: pointer on List: no destructor called
- string sName: string object: destructor called
- vector<char> cvStuff: vector object: destructor called

好消息：您无事可做。 析构函数声明在这里甚至没有用。

如果您在析构函数中删除next ，那么删除一个项目将删除列表中的所有其他项目：不是很有用。

（并且您的List对象应该称为Node ）。 列表是所有节点的链接结果，由您创建的第一个节点保存。