为什么'；此代码是否适用于删除链接列表中的节点？ 我一直在学习链表如何工作，并开始在C++中构建一个实现概念的方法。在我做了一个删除所有节点的函数之前，一切都很顺利。我找到了一个解决方案（即注释代码），但我似乎无法理解为什么其他代码不起作用

Node对象是使用“new”创建的类的实例。所以“delete”是用来删除它的

我认为这可能与删除对象和重用指针变量有关。然后我遇到了这样一个问题： 我已经盯着它看了一段时间，试图找出它可能是什么，但我所研究的似乎都没有提供答案

到目前为止，我不认为这与我的实现有关，因为当用解决方案代码替换代码时，程序按预期工作

代码输出每个地址，但似乎并没有实际删除对象。如果我在Windows中运行该程序，该程序将实际锁定，并且永远不会离开while循环。不是无限循环，它只是被卡住，函数永远不会结束。如果我在C4Droid上运行它，程序不会锁定，但在函数退出后节点仍然存在

所以我的问题是，为什么当前的代码不能工作？（忽略注释代码。这是一个有效的解决方案。）指针变量有什么简单的地方我忽略了吗？先谢谢你

void LinkedList::deleteAll() {
Node *pCurrent = pHead;

while(pCurrent){
    Node *pNext = pCurrent->pNext;
    std::cout << pCurrent << std::endl;
    delete pCurrent;
    pCurrent = nullptr;
    pCurrent = pNext;

//  pHead = pHead->pNext;
//  delete pCurrent;
//  pCurrent = pHead;
}
}

LinkedList.h

/*
 * LinkedList.h
 *
 *  Created on: Oct 3, 2015
 *      Author: Anthony
 */

#ifndef LINKEDLIST_H_
#define LINKEDLIST_H_

#include<string>
using std::string;

class LinkedList {
public:
    LinkedList();
    virtual ~LinkedList();
    int length();
    void addNode(string nodeContent);
    void deleteNode(string nodeContent);
    void deleteAll();
private:
    class  Node{
    public:
        Node(string content):data(content){}
        string getData(){
            return data;
        }
        Node *pNext = nullptr;
    private:
        string data;
    };

    Node *pHead = nullptr;

};

#endif /* LINKEDLIST_H_ */

/*
*LinkedList.h
*
*创建日期：2015年10月3日
*作者：安东尼
*/
#ifndef链接列表_
#定义链接列表_
#包括
使用std:：string；
类链接列表{
公众：
LinkedList（）；
虚拟~LinkedList（）；
int length（）；
void addNode（字符串nodeContent）；
void deleteNode（字符串nodeContent）；
void deleteAll（）；
私人：
类节点{
公众：
节点（字符串内容）：数据（内容）{}
字符串getData（）{
返回数据；
}
Node*pNext=nullptr；
私人：
字符串数据；
};
节点*pHead=nullptr；
};
#endif/*链接列表*/

LinkedList.cpp

    /*
 * LinkedList.cpp
 *
 *  Created on: Oct 3, 2015
 *      Author: Anthony
 */

#include "LinkedList.h"
#include <iostream>
LinkedList::LinkedList() {
    // TODO Auto-generated constructor stub

}

LinkedList::~LinkedList() {
    // TODO Auto-generated destructor stub
}

int LinkedList::length() {
    Node *current = pHead;
    int count = 0;
    while(current){
        count++;
        current = current->pNext;
    }
    return count;
}

void LinkedList::addNode(std::string nodeContent) {
    Node *newNode = new Node(nodeContent);
    newNode->pNext = pHead;
    pHead = newNode;
}

void LinkedList::deleteNode(std::string nodeContent) {
}

void LinkedList::deleteAll() {
    Node *pCurrent = pHead;

    while(pCurrent){
        Node *pNext = pCurrent->pNext;
        std::cout << pCurrent->pNext << std::endl;
        delete pCurrent;
        pCurrent = nullptr;
        pCurrent = pNext;

    //  pHead = pHead->pNext;
    //  delete pCurrent;
    //  pCurrent = pHead;
    }
}

/*
*LinkedList.cpp
*
*创建日期：2015年10月3日
*作者：安东尼
*/
#包括“LinkedList.h”
#包括
LinkedList:：LinkedList（）{
//TODO自动生成的构造函数存根
}
LinkedList:：~LinkedList（）{
//TODO自动生成的析构函数存根
}
int LinkedList:：length（）{
节点*电流=pHead；
整数计数=0；
while（当前）{
计数++；
当前=当前->pNext；
}
返回计数；
}
void LinkedList:：addNode（std:：string nodeContent）{
Node*newNode=新节点（nodeContent）；
newNode->pNext=pHead；
pHead=新节点；
}
void LinkedList:：deleteNode（std:：string nodeContent）{
}
void LinkedList:：deleteAll（）{
节点*pCurrent=pHead；
while（pCurrent）{
节点*pNext=pCurrent->pNext；
std：：cout pNext pNext；
//删除pCurrent；
//pCurrent=pHead；
}
}

main.cpp

/*
 * main.cpp
 *
 *  Created on: Oct 3, 2015
 *      Author: Anthony
 */

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

int main(int argc, char **argv){

    using namespace std;

    LinkedList list = LinkedList();
    list.addNode(string("Test"));
    list.addNode(string("Test1"));

    list.deleteAll();
    cout << list.length() << endl;

    return 0;
}

/*
*main.cpp
*
*创建日期：2015年10月3日
*作者：安东尼
*/
#包括
#包括“LinkedList.h”
int main（int argc，字符**argv）{
使用名称空间std；
LinkedList=LinkedList（）；
addNode（字符串（“测试”））；
addNode（字符串（“Test1”））；
list.deleteAll（）；
cout使用“new”关键字创建对象时涉及两个主要内存区域，“call stack”用于跟踪局部变量和调用了哪些函数，“heap”用于以牺牲速度为代价保存大量数据

当您声明局部变量pCurrent时，会在“调用堆栈”上创建一个指针，就像局部整型变量被放在声明为“int a”的堆栈上一样；不需要删除堆栈上的局部变量

但是，所有使用“new”创建的对象都需要删除，因为它们是在堆上创建的

正如PaulMcKenzie所写，确保将头部指针也设置为null

void LinkedList::deleteAll() {

    Node *pCurrent = pHead;

    while(pCurrent){
        Node *pNext = pCurrent->pNext;
        std::cout << pCurrent << std::end;
        delete pCurrent;

        pCurrent = pNext;
    }

    pHead = nullptr;
}

void LinkedList:：deleteAll（）{
节点*pCurrent=pHead；
while（pCurrent）{
节点*pNext=pCurrent->pNext；
std:：cout使用“new”关键字创建对象时涉及两个主要内存区域，“call stack”用于跟踪局部变量和调用了哪些函数，“heap”用于以牺牲速度为代价保存大量数据

当您声明局部变量pCurrent时，会在“调用堆栈”上创建一个指针，就像局部整型变量被放在声明为“int a”的堆栈上一样；不需要删除堆栈上的局部变量

但是，所有使用“new”创建的对象都需要删除，因为它们是在堆上创建的

正如PaulMcKenzie所写，确保将头部指针也设置为null

void LinkedList::deleteAll() {

    Node *pCurrent = pHead;

    while(pCurrent){
        Node *pNext = pCurrent->pNext;
        std::cout << pCurrent << std::end;
        delete pCurrent;

        pCurrent = pNext;
    }

    pHead = nullptr;
}

void LinkedList:：deleteAll（）{
节点*pCurrent=pHead；
while（pCurrent）{
节点*pNext=pCurrent->pNext；
std：：cout假设（这是一个很大的假设）您的链表放在一起是正确的，那么为什么注释代码工作而新代码不工作的问题相当简单

  pHead = pHead->pNext;
  delete pCurrent;
  pCurrent = pHead;

在上面的代码中，您在循环时在列表中移动
pHead
指针。循环完成后，
pHead
指针为
nullptr
，这是正确的，因为列表现在为空

Node *pNext = pCurrent->pNext;
    std::cout << pCurrent << std::endl;
    delete pCurrent;
    pCurrent = nullptr;
    pCurrent = pNext;

假设（这是一个很大的假设）你的链表放在一起是正确的，那么为什么注释代码有效而新代码无效的问题就相当简单了

  pHead = pHead->pNext;
  delete pCurrent;
  pCurrent = pHead;

在上面的代码中，您在循环时在列表中移动
pHead
指针。循环完成后，
pHead
指针为
nullptr
，这是正确的，因为列表现在为空

Node *pNext = pCurrent->pNext;
    std::cout << pCurrent << std::endl;
    delete pCurrent;
    pCurrent = nullptr;
    pCurrent = pNext;

你的
节点
类有析构函数吗？如果有，请