Question

我正在开发一个Linked List类。每当我编译时，我都没有错误或警告。但是，可执行文件停止工作（使用Windows Dev C ++）。我推断出问题是我的析构函数。

我的理解是使用delete关键字为动态创建的对象调用析构函数，或者每当对象超出堆栈中对象的作用域时。

我认为我的问题发生在我的堆栈对象（Node * result）调用析构函数时，但不是很确定。

这是我的头文件：

    #ifndef Node_H
    #define Node_H

    class Node{
          int data;
          Node* next;

    public:
           Node(int data);       
           ~Node();
           void insert(int d);
           Node* remove(int d);
           void removeDups(void);
           Node* add(Node* a, Node* b);
           void printOut(void);
    };

    #endif

重复部署.cpp文件：

    #include <iostream>
    #include "Node.h"

    using namespace std;

    Node::Node(int d){
          data = d;
          next = NULL;
          }

    Node::~Node(){
           Node* n = this;
           Node* delptr;

           while(n->next != NULL){
                         delptr = n;
                         n = n->next;
                         delete delptr;
                         }
           delete n;            

        }

    void Node::insert(int d){

          Node* n = this;
          Node* current = new Node(d);

          while(n->next != NULL){
                  n = n->next;                   
                  }

          n->next = current;
          }

主：

    int main (void){
        int i = 0;

        Node* root = new Node(111);
        Node* result;

        root->printOut();

        for (i = 0; i < 11; i++){
            root->insert(i);
            } 

        root->printOut();

        delete root; 
        getchar();
        return 0;   
    }

另外，我在USB上运行Dev C ++。我希望这是为了防止我的操作系统内存泄漏。这是对的吗？

由于

- Tring Vu

Answer 1

delete delptr;

这肯定是错的，因为最初是delptr == this，而你是一个析构函数（即代码已经在解除分配请求时被调用）

Answer 2

编写资源管理时的关键思想是尽可能简化概念和职责。

您拥有的是一个负责删除其所有子节点的根节点。与单个节点相比，您更倾向于使用负责删除的结构。

常见的事情是创建一个LinkedList类型/类以及一个Node类。这将简化职责。 LinkedList类型将拥有节点，并且作为所有者负责在其析构函数中删除。

insert和remove / removeDups将进入LinkedList类。该节点可以提供诸如

之类的功能

insert(Node* afterThisNode){  
    this->next = afterThisNode->next;
    afterThisNode->next= this;
}

链表析构函数

2 个答案: