C++ C++；如何在不丢失内存的情况下删除节点？

我就是不能让这个单一的链表没有记忆损失的工作。我在谷歌上搜索过，就我所能看到的而言，我做了大多数人建议的事情。我还尝试了“free（deleteNode）”而不是“deleteDeleteNode”。有人认为他们知道答案吗

先谢谢你

我正在尝试使用此代码段插入和删除

List l{};
l.insert(5);
l.remove(5);

我打赌错误在我的

remove

功能中：

void List::remove(int input){

    if(top -> getValue() == input){
        Node * deleteNode = new Node;
        deleteNode = top;
        top = top -> getNext();
        delete deleteNode;
        amount--;
        return;
    }

    Node * tmpNode;
    tmpNode = new Node(top);

    while(tmpNode -> getValue() != 0){
        if(tmpNode -> getNext() -> getValue() == input){
            Node * deleteNode;
            deleteNode = new Node(tmpNode -> getNext());
            tmpNode -> setNext(deleteNode -> getNext());
            deleteNode -> setNext(nullptr);
            delete deleteNode;
            amount--;
            return;
        }
        tmpNode = tmpNode -> getNext();
    }
}

我的抄送文件：

#include <cstddef>
using namespace std;
#include "List.h"
#include <iostream>

List::List() : amount(0), top(nullptr) {
}

List::List(Node* input) : List(){
    top = input;
}

List::~List(){//destructor
    while( top != nullptr){
        remove( top -> getValue());
    }
}

List::Node::~Node(){//destructor
    next = nullptr;
    //this =NULL;
}

    List::List(List const& other) : List(){
        *this = other;
    }

    List::List(List && other) : List(){ // move constructor
       Node* tmpNode = other.top;
       other.top = top;
       top = tmpNode;
       int tmpAmount = size();
        setSize(other.size());
        other.setSize(tmpAmount);
    }

    List & List::operator=(List && other){ // move assignment
        Node* tmpNode = other.top;
        other.top = top;
        top = tmpNode;
        int tmpAmount = size();
        other.size();
        setSize(other.size());
        other.setSize(tmpAmount);
        return *this;
    }

    List & List::operator=(List const& other){// copy assignment
        Node * tmpNode; 
        tmpNode = other.top;

        while(tmpNode != nullptr){
            insert(tmpNode -> getValue());
            tmpNode = tmpNode -> getNext();
        }

        return *this;
    }

void List::setSize(int input){
    amount = input;
}

void List::insert(int input){
    Node* newNode;
    newNode = new Node(input);
    if(!top){
        top = newNode;
        amount++;
        return;
    }

    if(input > top -> getValue()){
        newNode -> setNext(top);
        top = newNode;
        amount++;
        return;
    }

    top -> putIterator(newNode);
    amount++;
    return;
}

string List::print(){
    if(top == nullptr){
        return "";
    }
    string output = to_string(top -> getValue());
    if(top -> getNext() == nullptr){
        return output;
    }
    return top -> getNext() -> print(output);
}

void List::remove(int input){

    if(top -> getValue() == input){
        Node * deleteNode = new Node;
        deleteNode = top;
        top = top -> getNext();
        delete deleteNode;
        amount--;
        return;
    }

    Node * tmpNode;
    tmpNode = new Node(top);

    while(tmpNode -> getValue() != 0){
        if(tmpNode -> getNext() -> getValue() == input){
            Node * deleteNode;
            deleteNode = new Node(tmpNode -> getNext());
            tmpNode -> setNext(deleteNode -> getNext());
            deleteNode -> setNext(nullptr);
            delete deleteNode;
            amount--;
            return;
        }
        tmpNode = tmpNode -> getNext();
    }
}

List::Node List::find(int input){
    return iterate(input).getNext();
}

List::Node List::iterate(int input){
    return top -> iterate(input);
}

bool List::isEmpty(){
    if(size()==0){
        return true;
    }
    return false;
}

int List::size(){
    return amount;
}

List::Node::Node(int input, Node &nextInput){
    value = input;
    next = &nextInput;
}

List::Node::Node(int input){
    value = input;
    next = nullptr;
}

List::Node::Node(const Node* input){
    *this = *input;
}

List::Node* List::Node::getNext(){
    return next;
}

void List::Node::setNext(Node* input){
    next = input;
}

int List::Node::getValue(){
    return value;
}

/*
void List::Node::deleteNode(){
    delete *this;
}*/

void List::Node::putIterator(Node* newNode){
    if (next == nullptr){
        next = newNode;
        next -> setNext(nullptr);
        return;
    }

    if(getValue() == newNode -> getValue()){
        newNode -> setNext(getNext());
        setNext(newNode);
        return; 
    }

    if(next -> value < newNode -> value && value > newNode -> value){
        newNode -> setNext(getNext());
        setNext(newNode);
        return;
    }

    next -> putIterator(newNode);
    return;
}

string List::Node::print(string input){
    input = input + ", " + to_string(value);
    if(next == nullptr){
        return input;
    }
    return next -> print(input);
}

List::Node List::Node::iterate(int input){
    if (next -> value==input){
        return *this;
    }
    if (next -> value==0){
        return nullptr;
    }

    return next ->iterate(input);
}

bool List::Node::operator!() const{
    if(value == 0){
        return true;
    }
    return false;
}

#包括
使用名称空间std；
#包括“List.h”
#包括
列表：：列表（）：金额（0），顶部（空PTR）{
}
列表：：列表（节点*输入）：列表（）{
top=输入；
}
列表：：~List（）{//析构函数
while（顶部！=nullptr）{
删除（top->getValue（））；
}
}
列表：：节点：：~Node（）{//析构函数
next=nullptr；
//这=空；
}
列表：：列表（列表常量和其他）：列表（）{
*这个=其他；
}
List:：List（List&&other）：List（）{//move构造函数
Node*tmpNode=other.top；
other.top=top；
顶部=tmpNode；
int tmpAmount=size（）；
setSize（其他.size（））；
其他.设置尺寸（tmpAmount）；
}
列表和列表：：运算符=（列表和其他）{//move赋值
Node*tmpNode=other.top；
other.top=top；
顶部=tmpNode；
int tmpAmount=size（）；
其他。大小（）；
setSize（其他.size（））；
其他.设置尺寸（tmpAmount）；
归还*这个；
}
List&List:：operator=（List const&other）{//复制赋值
节点*tmpNode；
tmpNode=other.top；
while（tmpNode！=nullptr）{
插入（tmpNode->getValue（））；
tmpNode=tmpNode->getNext（）；
}
归还*这个；
}
无效列表：：设置大小（int输入）{
金额=投入；
}
无效列表：：插入（int输入）{
节点*新节点；
newNode=新节点（输入）；
如果（！顶部）{
top=newNode；
金额++；
返回；
}
如果（输入>顶部->获取值（））{
新建节点->设置下一步（顶部）；
top=newNode；
金额++；
返回；
}
top->putIterator（新节点）；
金额++；
返回；
}
字符串列表：：print（）{
if（top==nullptr）{
返回“”；
}
字符串输出=to_字符串（top->getValue（））；
if（top->getNext（）==nullptr）{
返回输出；
}
返回top->getNext（）->打印（输出）；
}
无效列表：：删除（int输入）{
if（top->getValue（）==输入）{
节点*deleteNode=新节点；
deleteNode=top；
top=top->getNext（）；
删除删除节点；
金额--；
返回；
}
节点*tmpNode；
tmpNode=新节点（顶部）；
而（tmpNode->getValue（）！=0）{
如果（tmpNode->getNext（）->getValue（）==输入）{
节点*删除节点；
deleteNode=新节点（tmpNode->getNext（））；
tmpNode->setNext（deleteNode->getNext（））；
deleteNode->setNext（nullptr）；
删除删除节点；
金额--；
返回；
}
tmpNode=tmpNode->getNext（）；
}
}
列表：：节点列表：：查找（int输入）{
返回iterate（input.getNext（）；
}
列表：：节点列表：：迭代（int输入）{
返回顶部->迭代（输入）；
}
bool List:：isEmpty（）{
如果（size（）=0）{
返回true；
}
返回false；
}
int List:：size（）{
退货金额；
}
列表：：节点：：节点（int输入、节点和nextInput）{
值=输入；
下一步=&nextInput；
}
列表：：节点：：节点（int输入）{
值=输入；
next=nullptr；
}
列表：：节点：：节点（常量节点*输入）{
*这个=*输入；
}
列表：：节点*列表：：节点：：getNext（）{
下一步返回；
}
无效列表：：节点：：设置下一步（节点*输入）{
下一步=输入；
}
int List:：Node:：getValue（）{
返回值；
}
/*
无效列表：：节点：：删除节点（）{
删除*本条；
}*/
void List:：Node:：putIterator（Node*newNode）{
if（next==nullptr）{
next=newNode；
下一步->设置下一步（空PTR）；
返回；
}
如果（getValue（）==newNode->getValue（））{
newNode->setNext（getNext（））；
setNext（newNode）；
返回；
}
如果（下一步->值<新节点->值和值>新节点->值）{
newNode->setNext（getNext（））；
setNext（newNode）；
返回；
}
next->putIterator（新节点）；
返回；
}
字符串列表：：节点：：打印（字符串输入）{
输入=输入+“，”+到字符串（值）；
if（next==nullptr）{
返回输入；
}
返回下一步->打印（输入）；
}
列表：：节点列表：：节点：：迭代（int输入）{
如果（下一步->值==输入）{
归还*这个；
}
如果（下一步->值==0）{
返回空ptr；
}
返回下一步->迭代（输入）；
}
布尔列表：：节点：：运算符！（）常数{
如果（值==0）{
返回true；
}
返回false；
}

我的头文件：

#ifndef _LIST_H_
#define _LIST_H_
#include <string>

class List
{
  public:
    List();

    ~List(); //destructor
    List(List const &other);
    List(List &&other);                 // move constructor
    List &operator=(List &&other);      // move assignment
    List &operator=(List const &other); // copy assignment

  class Node
    {
      public:
        Node() = default;
        ~Node();
        Node(int input, Node &nextInput);
        Node(int input);
        Node(const Node *input);
        Node *getNext();
        void setNext(Node *input);
        int getValue();
        Node iterate(int input);
        void putIterator(Node *newNode);
        void deleteNode();
        bool operator!() const;
        std::string print(std::string input);

      private:
        int value;
        Node *next;
    };

    List(Node* input);
    void insert(int input);
    void remove(int input);
    Node iterate(int input);
    int size();
    bool isEmpty();
    Node find(int input);
    std::string print();
    void setSize(int input);

   private:

    Node *top;
    int amount;
};

#endif

\ifndef\u列表_
#定义列表_
#包括
班级名单
{
公众：
List（）；
~List（）；//析构函数
列表（列表常量和其他）；
列表（列表和其他）；//移动构造函数
列表和运算符=（列表和其他）；//移动分配
List&operator=（List const&other）；//复制赋值
类节点
{
公众：
Node（）=默认值；
~Node（）；
节点（int输入、节点和nextInput）；
节点（int输入）；
节点（常数节点*输入）；
节点*getNext（）；
void setNext（节点*输入）；
int getValue（）；
节点迭代（int输入）；
无效迭代器（节点*新节点）；
void deleteNode（）；
布尔运算符！（）常数；
std：：字符串打印（std：：字符串输入）；
私人：
int值；
节点*下一步；
};
列表（节点*输入）；
无效插入（int输入）；
无效删除（int输入）；
节点迭代（int输入）；
int size（）；
bool是空的（）；
节点查找（int输入）；
std:：string print（）；
无效设置大小（int输入）；
私人：
节点*顶部；
整数金额；
};
#恩迪夫

您正在调用新的构造函数，然后设置指针，这将导致内存丢失

Node * deleteNode = new Node;

为不需要的新节点分配内存。这

void List::remove(int input){

    if(top -> getValue() == input){
        Node * deleteNode;
        deleteNode = top;
        top = top -> getNext();
        delete deleteNode;
        amount--;
        return;
    }

    Node * tmpNode;
    tmpNode = top;

    while(tmpNode -> getValue() != 0){
        if(tmpNode -> getNext() -> getValue() == input){
            Node * deleteNode;
            deleteNode = tmpNode -> getNext());
            tmpNode -> setNext(deleteNode -> getNext());
            deleteNode -> setNext(nullptr); // you could probably delete this line
            delete deleteNode;
            amount--;
            return;
        }
        tmpNode = tmpNode -> getNext();
    }

}

void List::remove(int x) {
    auto p = ⊤
    while (*p && p[0]->value != x)
        p = &p[0]->next;
    if (*p)
        delete std::exchange(*p, p[0]->next);
}

void List::remove(int x) {
    auto curr = top;
    curr = nullptr;
    auto next = top;
    while (next && next->value != x) {
        curr = next;
        next = next->next;
    }
    if (!next)
        return;
    (curr ? curr->next : top) = next->next;
    delete next;
}