为什么链表插入节点"new"后没有"delete"

Question

我一直在尝试通过阅读一些文本和查找资料来理解 C++ 中的内存分配。我经常看到人们应该总是在“新建”之后调用“删除”。但是，我也看到这样的代码：

void LinkedList::add(int data){
    Node* node = new Node();
    node->data = data;
    node->next = this->head;
    this->head = node;
    this->length++;
}

在链表或堆栈等结构中。

我看到了一些关于 SO 的很好的解释，比如：

Why should C++ programmers minimize use of 'new'? When to use "new" and when not to, in C++?

但是我仍然很困惑为什么人们不会在这里为一个新节点调用“删除”。

编辑：让我澄清一下我的问题。我明白为什么不立即以相同的方法调用 delete 。但是，在同一代码中，我没有看到与添加匹配的删除语句。我假设程序结束后所有内容都被删除，但我很困惑没有明显匹配的删除语句（即：计算代码中的所有新闻，计算代码中的所有删除，它们不匹配）。

编辑：这是我正在查看的来源：https://www.geeksforgeeks.org/linked-list-set-2-inserting-a-node/

他们链表的代码：

// A complete working C++ program to demonstrate
//  all insertion methods on Linked List
#include <bits/stdc++.h>
using namespace std;
 
// A linked list node
class Node
{
    public:
    int data;
    Node *next;
};
 
/* Given a reference (pointer to pointer)
to the head of a list and an int, inserts
a new node on the front of the list. */
void push(Node** head_ref, int new_data)
{
    /* 1. allocate node */
    Node* new_node = new Node();
 
    /* 2. put in the data */
    new_node->data = new_data;
 
    /* 3. Make next of new node as head */
    new_node->next = (*head_ref);
 
    /* 4. move the head to point to the new node */
    (*head_ref) = new_node;
}
 
/* Given a node prev_node, insert a new node after the given
prev_node */
void insertAfter(Node* prev_node, int new_data)
{
    /*1. check if the given prev_node is NULL */
    if (prev_node == NULL)
    {
        cout<<"the given previous node cannot be NULL";
        return;
    }
 
    /* 2. allocate new node */
    Node* new_node = new Node();
 
    /* 3. put in the data */
    new_node->data = new_data;
 
    /* 4. Make next of new node as next of prev_node */
    new_node->next = prev_node->next;
 
    /* 5. move the next of prev_node as new_node */
    prev_node->next = new_node;
}
 
/* Given a reference (pointer to pointer) to the head
of a list and an int, appends a new node at the end */
void append(Node** head_ref, int new_data)
{
    /* 1. allocate node */
    Node* new_node = new Node();
 
    Node *last = *head_ref; /* used in step 5*/
 
    /* 2. put in the data */
    new_node->data = new_data;
 
    /* 3. This new node is going to be
    the last node, so make next of
    it as NULL*/
    new_node->next = NULL;
 
    /* 4. If the Linked List is empty,
    then make the new node as head */
    if (*head_ref == NULL)
    {
        *head_ref = new_node;
        return;
    }
 
    /* 5. Else traverse till the last node */
    while (last->next != NULL)
        last = last->next;
 
    /* 6. Change the next of last node */
    last->next = new_node;
    return;
}
 
// This function prints contents of
// linked list starting from head
void printList(Node *node)
{
    while (node != NULL)
    {
        cout<<" "<<node->data;
        node = node->next;
    }
}
 
/* Driver code*/
int main()
{
    /* Start with the empty list */
    Node* head = NULL;
     
    // Insert 6. So linked list becomes 6->NULL
    append(&head, 6);
     
    // Insert 7 at the beginning.
    // So linked list becomes 7->6->NULL
    push(&head, 7);
     
    // Insert 1 at the beginning.
    // So linked list becomes 1->7->6->NULL
    push(&head, 1);
     
    // Insert 4 at the end. So
    // linked list becomes 1->7->6->4->NULL
    append(&head, 4);
     
    // Insert 8, after 7. So linked
    // list becomes 1->7->8->6->4->NULL
    insertAfter(head->next, 8);
     
    cout<<"Created Linked list is: ";
    printList(head);
     
    return 0;
}
 
 
// This code is contributed by rathbhupendra

Answer 1

您引用的代码在某些时候应该 delete 节点。事实上，该代码展示了大量糟糕的 C++ 实践。它不会删除节点，因为它是错误的代码。

哦，顺便说一句：忽略您链接到的网站上的任何内容。如果该站点上有有用的东西，那只是偶然。

Answer 2

通常 new 会做一些事情。它在堆上（动态内存所在的地方）为一个对象分配内存，并在该地址初始化一个对象。

当你的函数中有这样的变量时：

void example(){
    int a;
    char b;
}

它们驻留在栈上，当函数returns时，那些变量不再存在。使用 new 可以在堆栈外（堆上）获取内存。好消息是这在整个函数调用过程中持续存在。它在函数调用中持续存在的坏处。这很好，因为有时数组长度未知，因此无法在堆栈上分配它们，或者您需要一个堆栈不适合的大缓冲区。这很糟糕，因为如果你忘记它，它就不会消失。它只会坐在那里占用内存。 delete，基本上是析构地址处的对象，然后returns内存到OS。这就是为什么人们说 delete 应该在 new 之后调用。

幸运的是，在现代 C++ 中，您（通常）不需要使用原始指针，也不必担心这一点。 std::shared_ptr<T> 由 std::make_shared<T,Args...> 创建，std::unique_ptr<T> 由 std::make_unique<T,Args...> 创建。这些是指针的包装器。 std::shared_ptr<T>就是T*，但是当大家失去指向对象的指针时，内存就归还了。 std::unique_ptr<T> 相同，但仅存在一个引用。

来自 cppreference 的 std::unique_ptr<T> 链表：

#include <memory>
struct List {
  struct Node {
    int data;
    std::unique_ptr<Node> next;
    Node(int data) : data{data}, next{nullptr} {}
  };
  List() : head{nullptr} {};
  // N.B. iterative destructor to avoid stack overflow on long lists
  ~List() { while(head) head = std::move(head->next); }
  // copy/move and other APIs skipped for simplicity
  void push(int data) {
    auto temp = std::make_unique<Node>(data);
    if(head) temp->next = std::move(head);
    head = std::move(temp);
  }
private:
  std::unique_ptr<Node> head;
};

关于应尽量减少使用 new 的另一个原因：除了上述潜在内存泄漏问题外，它非常昂贵 (std::make_shared/std::make_unique但是仍然有这个问题），因为程序需要请求内核授予它一些内存，这意味着必须进行昂贵的系统调用。

为什么链表插入节点"new"后没有"delete"

Why no "delete" after "new" in linked list insert node

c++

linked-list

new-operator

delete-operator