C++ 中的列表析构函数

我刚刚实现了链接列表。它工作得很好，但甚至很难，我已经看到我无法在 Node 上创建工作析构函数的符号，这就是为什么它在代码中未实现。

1. 我需要在节点上实现工作析构函数
2. List 的析构函数，但这一个很简单，我将只使用 Node 类的析构函数（但我需要这个）。
3. 使列表对节点友好，这样我就不必使用 getNext()，但我想我可以 自己处理（不知道如何处理，但我会找出答案）。

请看一下代码，它完全没问题，只要复制它就可以了。

#include <cstdio>
#include <cmath>
#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;

class Node {
public:
    Node(Node* next, int wrt) {
        this->next = next;
        this->wrt = wrt;
    }

    Node(const Node& obiekt) {
        this->wrt = obiekt.wrt;
        this->next = obiekt.next;
    }
    ~Node() {}

    void show() {
        cout << this->wrt << endl;
    }

    int getWrt(){
        return this->wrt;
    }

    Node* getNext(){
        return this->next;
    }

    void setNext(Node* node){
        this->next = node;
    }

 private:
    Node* next;
    int wrt;
};

class List{
public:
    List(int wrt){
        this->root = new Node(NULL, wrt);
    }

    List(const List& obiekt){
        memcpy(&this->root,&obiekt.root,sizeof(int));
        Node* el = obiekt.root->getNext();
        Node* curr = this->root;
        Node* next;
        while(el != NULL){
            memcpy(&next,&el,sizeof(int));
            curr->setNext(next);
            curr = next;
            next = curr->getNext();
            el = el->getNext();
    /*      curr->show();
            next->show();
            el->show(); */
        }
    }

    void add(int wrt){
        Node* node = new Node(NULL, wrt);
        Node* el = this->root;
        while(el->getNext() != NULL){
            //el->show();
            el = el->getNext();
        }
        el->setNext(node);
    }

    void remove(int index){
        Node* el = this->root;
        if(index == 0){
             //deleting old one
             this->root = this->root->getNext();
        }
        else{
            int i  = 0;
            while(el != NULL && i < index - 1){
            //  el->show();
                el = el->getNext();
                i++;
            }
            if(el!=NULL){
                Node* toRem = el->getNext();
                Node* newNext = toRem->getNext();
                el->setNext(newNext);
                //deleteing old one
            }
        }
    }

    void show(){
        Node* el = this->root;
        while(el != NULL){
            el->show();
            el = el->getNext();
        }
    }

    ~List(){}

private:
    Node* root;
};

int main(){
    List* l = new List(1); //first list
    l->add(2);
    l->add(3);
    l->show();
    cout << endl;

    List* lala = new List(*l); //lala is second list created by copy cosntructor
    lala->show();
    cout << endl;

    lala->add(4);
    lala->remove(0);
    lala->show();

    return 0;
}

我建议你从实现析构函数开始List。由于您通过使用动态分配内存new，你应该使用释放它delete。 （如果您使用new[]， 这将是delete[]):

~List()
{
    Node* currentNode = this->root; // initialize current node to root
    while (currentNode)
    {
        Node* nextNode = currentNode->getNext();    // get next node
        delete currentNode;                         // delete current
        currentNode = nextNode;                     // set current to "old" next
    }
}

一旦你有了正确的析构函数，你应该尝试你的复制构造函数是否正确：

List* lala = new List(*l);
delete l; // delete list that was used to create copy, shouldn't affect copy

您会发现您的复制构造函数是错误的，并且还会导致您的应用程序崩溃。为什么？因为目的复制构造函数就是创建一个new对象作为现有对象的副本。你的复制构造函数只是复制指针假设sizeof(Node*)等于sizeof(int)。它应该看起来像这样：

List(const List& list)
{
    // if empty list is being copied:
    if (!list.root)
    {
        this->root = NULL;
        return;
    }

    // create new root:
    this->root = new Node(NULL, list.root->getWrt());

    Node* list_currentNode = list.root;
    Node* this_currentNode = this->root;
    while (list_currentNode->getNext())
    {
        // create new successor:
        Node* newNode = new Node(NULL, list_currentNode->getNext()->getWrt());
        this_currentNode->setNext(newNode);
        this_currentNode = this_currentNode->getNext();
        list_currentNode = list_currentNode->getNext();
    }
}

还有你的功能remove是错误的，因为它“删除”了对某个节点的引用，但从未释放该节点所在的内存。delete应该调用以释放该内存。

“我需要在节点上实现工作析构函数”- 不，你不知道。节点本身不分配任何内存，因此它不应该释放任何内存。节点不应该负责销毁Node* next也不清理存储它的内存。不要实现 Node 的析构函数或复制构造函数。您还想阅读以下内容：什么是三法则？ https://stackoverflow.com/q/4172722/1168156

“使列表对 Node 友好，这样我就不必使用 getNext()”- 你想说在 Node 类中，class List is its friend:

class Node
{
    friend class List; // <-- that's it

请注意，您的代码包含的这 5 个标头中只需要一个：<iostream>。 还要注意写using namespace std;在文件的开头被认为是不好的做法因为它可能会导致某些类型的名称变得不明确。在小范围内明智地使用它或使用std::前缀代替。