你好，我对编写一个合适的析构函数有点模棱两可：
class SLLst
{
public:
SLLst() = default;
SLLst(const SLLst&);
SLLst& operator=(SLLst);
~SLLst();
void insert(int);
void remove(int);
private:
SLLst* next = nullptr;
int data = 0;
friend void swap(SLLst&, SLLst&);
friend std::ostream& print(std::ostream&, const SLLst&);
};
SLLst::SLLst(const SLLst& rhs) :
next(rhs.next ? new SLLst() : nullptr),
data(rhs.data)
{
cout << "cpy-ctor" << endl;
}
SLLst& SLLst::operator=(SLLst rhs)
{
cout << "operator=(SLLst)" << endl;
using std::swap;
swap(*this, rhs);
return *this;
}
void swap(SLLst& lhs, SLLst& rhs)
{
cout << "operator=(SLLst)" << endl;
using std::swap;
swap(lhs.next, rhs.next);
swap(lhs.data, rhs.data);
}
SLLst::~SLLst()
{
cout << "dtor" << endl;
delete next;// is this enough?
// or should I use this code?
//SLLst* cur = next;
//SLLst* n = nullptr;
//while (cur != NULL) {
// n = cur->next;
// cur->next = nullptr;
// delete cur;
// cur = n;
//}
}
void SLLst::insert(int x)
{
SLLst* tmp = new SLLst();
tmp->data = x;
if (!next)
{
next = tmp;
return;
}
tmp->next = next;
next = tmp;
}
std::ostream& print(std::ostream& out, const SLLst& lst)
{
auto tmp = lst.next;
while (tmp)
{
out << tmp->data << ", ";
tmp = tmp->next;
}
return out;
}
如您所见，如果我只在析构函数中使用delete next;，那么我会调用它与列表中的节点一样多，但是为什么许多实现使用循环来释放节点，例如析构函数中的注释代码？
因为如果我只在
next上调用delete，那么析构函数将被递归调用，因此我认为我不需要循环来释放析构函数中的节点？ 对吗？何时应使用循环来释放析构函数中的节点？谢谢！
*如果我运行我的代码，我会得到：
81， 77， 57， 23， 16， 7， 5，
done
dtor
dtor
dtor
dtor
dtor
dtor
dtor
dtor
- 如您所见，dtor 被调用了 8 次;这是否意味着它已正确释放了所有节点？
如您所见，我是否接下来只使用删除; 在析构函数中，然后我得到与列表中的节点一样多的调用
是的。
因为如果我只在下一个调用 delete，那么析构函数将被递归调用，因此我认为我不需要循环来释放析构函数中的节点？ 对吗？
是的。
何时应使用循环来释放析构函数中的节点？
当你需要的时候。
但是为什么许多实现使用循环来释放节点，就像析构函数中的注释代码一样？
因为许多实现都是"类似 C 的"，并且不使用析构函数。所以他们需要这样做。
您正在充分利用C++的对象管理功能来"为您完成循环"。耶！
(虽然，老实说，我仍然会循环进行，因为你的方式可能非常繁重。
现在更进一步，切换到std::list(或std::forward_list(。 😏
立即，std：：unique_ptr 会为您处理这个问题，但如果您想自己做，那么它看起来像这样，请记住这是一个最小的例子。
RAII在C++中是一个非常重要的原则，它基本上意味着，在需要时分配，但在使用完时销毁。
因此，如果一个节点被指向，并且你删除了指向它的节点，那么该节点也应该销毁它指向的东西，因为它对它拥有所有权。
class List {
Node* first_node;
~List() {
delete first_node;
}
};
class Node {
~Node() {
delete next; // will then in turn destroy the one it points to untill one is nullptr, deleting nullptr is well defined in C++ nowadays
}
Node* next;
};
标准：：unique_ptr示例
class List {
std::unique_ptr<Node> first_node;
// default dtor
};
class Node {
std::unique_ptr<Node> next;
// default dtor
};