删除链表节点时调用析构函数 一直报错"SIGABRT" 求问版上C++大神！

我在做lintcode Remove all elements from a linked list of integers that have value val 这道题。Given 1->2->3->3->4->5->3, val = 3, you should return the list as 1->2->4->5。 题很简单，算法本身实现起来没什么问题。
我的问题是调用这个删除函数之后 不是linkedlist本身还有调用自己的析构函数么， 这时候就一直报错了。

代码的构成：
代码分三部分：
首先是Listnode的类和LLinkedlist的类（就是怎么通过ListNode建Linkedlist 打印Linkedlist这些）；
接下来是lintcode这道题要求我们实现的函数，[size=14.6667px]ListNode * removeElements(ListNode * head, int val)， 包裹在Solution类里， 也没问题，这个函数在lintcode可以AC。
接下来就是main drive，这里我首先建了linkedlist， 然后调用removeElements，然后打印新的链表。到这里都没问题。然后main函数准备结束，调用linkedlist的析构函数，在第26行出现报错。
不想当伸手党的，用Clion一步步设断点追到这个[size=14.6667px]问题，真的不知道怎么解决了:

我的测试数据 ： 很简单 链表是7->null 然后要删除的val就是7 返回应该是个空链表即null.

我的报错：
[size=14.6667px]报错截图如下：
[size=14.6667px]代码如下 （在ubuntu paste里格式更容易看 [size=14.6667px]https://paste.ubuntu.com/25314115/[size=14.6667px] ） 谢谢各位C++大大！ Bow！
[size=14.6667px]

1. #include <iostream>
   
2. using namespace std;
   
3. 
   
4. class ListNode{
   
5. public:
   
6.     int val;
   
7.     ListNode * next;
   
8.     ListNode(int val){
   
9.         this->val = val;
   
10.         this->next = NULL;
    
11.     }
    
12. };
    
13. class LinkedList{
    
14. private:
    
15.     ListNode * head;
    
16. public:
    
17.     LinkedList(){
    
18.         head = NULL;
    
19.     }
    
20.     ~ LinkedList(){
    
21.         ListNode * curr_node = head;
    
22.         while (curr_node != NULL){
    
23.             ListNode * delete_node = curr_node;
    
24.             curr_node = curr_node->next;
    
25.             delete_node->next = NULL; //断开delete_node
    
26.             delete delete_node;
    
27.         }
    
28.     }
    
29.     void insert(ListNode * node, int index){
    
30.         if (head == NULL){
    
31.             if (index != 0){
    
32.                 return;
    
33.             }
    
34.             head = node;
    
35.             return;
    
36.         }
    
37.         if (index == 0){
    
38.             node->next = head;
    
39.             head = node;
    
40.             return;
    
41.         }
    
42.         ListNode * current_node = head;
    
43.         int count = 0;
    
44. 
    
45.         while (current_node->next != NULL && count < index-1){
    
46.             current_node = current_node->next;
    
47.             count += 1;
    
48.         }
    
49.         if (count == index - 1){
    
50.             node->next = current_node->next;
    
51.             current_node->next = node;
    
52.         }
    
53.     }
    
54.     void output(ListNode * head){
    
55.         if (head == NULL){
    
56.             return;
    
57.         }
    
58.         if (head->next == NULL){
    
59.             cout << head->val << "->NULL";
    
60.             cout << endl;
    
61.             return;
    
62.         }
    
63.         ListNode * curr_node = head;
    
64.         while (curr_node->next != NULL){
    
65.             cout << curr_node->val << "->";
    
66.             curr_node = curr_node->next;
    
67.         }
    
68.         cout << curr_node->val << "->NULL";
    
69.         cout << endl;
    
70. 
    
71.     }
    
72. };
    
73. 
    
74. class Solution {
    
75. public:
    
76.     ListNode * removeElements(ListNode * head, int val) {
    
77.         if (head == nullptr){
    
78.             return head;
    
79.         }
    
80.         ListNode dummy(-1);  dummy.next = head;
    
81.         ListNode * curr = &dummy;
    
82.         while (curr->next){
    
83.             if (curr->next->val != val){
    
84.                 curr = curr->next;
    
85.             }
    
86.             else{
    
87.                 ListNode * temp = curr->next;
    
88.                 curr->next = temp->next;
    
89.                 temp->next = nullptr;
    
90.                 delete temp;
    
91.             }
    
92.         }
    
93.         return dummy.next;
    
94.     }
    
95. };
    
96. 
    
97. int main(){
    
98. 
    
99.     // create linkedlist;
    
100.     LinkedList linkedList;
     
101. 
     
102.     // record the head
     
103.     ListNode * head = new ListNode(7);
     
104.     linkedList.insert(head, 0);
     
105. 
     
106.     linkedList.output(head);
     
107.     cout << "*****************" << endl;
     
108. 
     
109.     Solution sol;
     
110.     ListNode * newHead = sol.removeElements(head, 7);
     
111. 
     
112.     linkedList.output(newHead);
     
113. 
     
114.     return 0;
     
115. }

复制代码

LZ太逗了，我那个帖子居然每个楼都加米了！！谢谢lz大米！不想当米饭桶，光吃不干，所以我帮lz看了下这问题。
这题问题有点复杂，我先描述下，你再看代码。
问题不是coding的问题，主要是lz对OOD的思想还没有领会。
lz的Solution 类对着lz的linkedlist类的head一阵猛改，可整个removeElement函数里根本没用到LinkedList这个类。那lz把人家head改的乱起八糟后，通知人家了吗？LinkedinList里那个head还指着原来的位置啊。
详细解释就是，你的行为本质是这样的：
LinkedList 的head ->[7] -> NULL
同时你在main函数里也有个局部变量head->[7]->null
然后你通过main函数的局部变量head把7删了,head->null，然后又把这个head赋给了newHead: newHead->null
但你过程中没碰LinkedList的head呀人家还指着head->[7已经delete，剩下一个undefined空间]->null
这时候这么一个严重corrupt的list要被扔进你的析构函数析构，肯定各种崩溃呀。

但我为啥说你这其实是OOD的问题呢，因为你要删除你的list上的一个节点，这个删除函数是改变list的结构的，这个删除函数理应定义在list上，而不是由第三方的class Solution来做。
如果你的removeElement是定义在list上，你根本不需要暴露listNode的细节，也不用暴露Head给外面，client也不需要知道head的存在的（当然这个跟你LintCode的题目要求已经不一样了，抛开lintcode，只从OOD角度来说），你的removeElement也好，insert也好，都是对着自己class的head操作，这样就不会出现你上面那个外人篡改自己的数据，而自己不知情的情况了。
下面是改后的代码。我主要是从正确使用OOD角度修改的，如果只是简单把你代码改的能过，不用这么大改动，但是那样的代码设计问题很大，将来保不定还会出别的怪bug。

1. #include <iostream>
   
2. using namespace std;
   
3. 
   
4. class LinkedList{
   
5. private:
   
6.     class ListNode{ // LisNode本身也属于LinkedList的实现细节，没必要暴露给外面
   
7.     public:
   
8.         int val;
   
9.         ListNode * next;
   
10.         ListNode(int val){
    
11.             this->val = val;
    
12.             this->next = NULL;
    
13.         }
    
14.     } * head;
    
15. public:
    
16.     LinkedList(){
    
17.         head = NULL;
    
18.     }
    
19.     ~ LinkedList(){
    
20.         ListNode * curr_node = head;
    
21.         while (curr_node != NULL){
    
22.             ListNode * delete_node = curr_node;
    
23.             curr_node = curr_node->next;
    
24.             delete_node->next = NULL; //断开delete_node
    
25.             delete delete_node;
    
26.         }
    
27.     }
    
28.     void insert(int val, int index){ // 如果客户想插入7，传7就好了呀，ListNode的定义不应该暴露client。
    
29.         ListNode * node = new ListNode(val); //你内部把7变成节点。
    
30.         if (head == NULL){
    
31.             if (index != 0){
    
32.                 return;
    
33.             }
    
34.             head = node;
    
35.             return;
    
36.         }
    
37.         if (index == 0){
    
38.             node->next = head;
    
39.             head = node;
    
40.             return;
    
41.         }
    
42.         ListNode * current_node = head;
    
43.         int count = 0;
    
44. 
    
45.         while (current_node->next != NULL && count < index-1){
    
46.             current_node = current_node->next;
    
47.             count += 1;
    
48.         }
    
49.         if (count == index - 1){
    
50.             node->next = current_node->next;
    
51.             current_node->next = node;
    
52.         }
    
53.     }
    
54.     void output(){ //体会OOD思想，output本身是在此LinkedList的一个操作，干嘛要传人一个node呢？操作就应该且必须是自己的node呀。
    
55.                    //你好好体会下，car有 Ignite()这个function，你需要定义成 void Ingite(Car mycar) 吗？不用的，因为Ignite的正确调用方法是 mycar.Ignite().
    
56.         if (head == NULL){
    
57.             return;
    
58.         }
    
59.         if (head->next == NULL){
    
60.             cout << head->val << "->NULL";
    
61.             cout << endl;
    
62.             return;
    
63.         }
    
64.         ListNode * curr_node = head;
    
65.         while (curr_node->next != NULL){
    
66.             cout << curr_node->val << "->";
    
67.             curr_node = curr_node->next;
    
68.         }
    
69.         cout << curr_node->val << "->NULL";
    
70.         cout << endl;
    
71.     }
    
72.     void removeElements(int val) { //同样道理，head不需要。
    
73.         if (head == nullptr){
    
74.             return;
    
75.         }
    
76.         ListNode dummy(-1);  dummy.next = head;
    
77.         ListNode * curr = &dummy;
    
78.         while (curr->next){
    
79.             if (curr->next->val != val){
    
80.                 curr = curr->next;
    
81.             }
    
82.             else{
    
83.                 ListNode * temp = curr->next;
    
84.                 curr->next = temp->next;
    
85.                 temp->next = nullptr;
    
86.                 delete temp;
    
87.             }
    
88.         }
    
89.         head = dummy.next;
    
90.     }
    
91.     //Bonus: Just a cooler way to do output, now you can cout<<linkedList<<endl; see below.
    
92.     friend ostream & operator<< (ostream & os, const LinkedList & ll)
    
93.     {
    
94.         auto head = ll.head;
    
95.         if (head == NULL){
    
96.             return os;
    
97.         }
    
98.         if (head->next == NULL){
    
99.             os << head->val << "->NULL";
    
100.             os << endl;
     
101.             return os;
     
102.         }
     
103.         ListNode * curr_node = head;
     
104.         while (curr_node->next != NULL){
     
105.             os << curr_node->val << "->";
     
106.             curr_node = curr_node->next;
     
107.         }
     
108.         os << curr_node->val << "->NULL";
     
109.         os << endl;
     
110.         return os;
     
111.     }
     
112. };
     
113. //这个Solution 类都多余，我直接全删了。反正你lintcode提交也过了不是？
     
114. int main(){
     
115.     // create linkedlist;
     
116.     LinkedList linkedList;
     
117.     linkedList.insert(7, 0);
     
118.     linkedList.insert(8, 0);
     
119.     linkedList.insert(7, 0);
     
120.     //linkedList.output();
     
121.     cout<<linkedList<<endl;
     
122.     cout << "*****************" << endl;
     
123.     linkedList.removeElements(7);
     
124.     //linkedList.output();
     
125.     cout<<linkedList<<endl;
     
126.     return 0;
     
127. }
     

复制代码