C++ C+；中的pop_back双链表中的垃圾值+；

在下面的代码中，我实现了双链表。我得到的输出是

56 2 3 4 0

而不是

56 2 3 4

。但是，如果我删除

lt.erase（5）；lt.推回（46）然后我得到正确的输出。我最初认为，
erase（）
有一些bug，但通过单独测试每个函数，我觉得这些bug还不错。然而，在这个组合中，我得到了一个额外的
0

#include <iostream>
using namespace std;

template <class T>
class LinkedList {
private:
    T data;
    LinkedList *prev, *next, *head, *tail;
public:
    LinkedList() : next(nullptr), head(nullptr), tail(nullptr), prev(nullptr){}
    LinkedList* get_node(T);
    void push_back(T);
    void insert(int, T);
    void pop_bak();
    void erase(int);
    void print();
};

template <typename T>
LinkedList<T>* LinkedList<T>:: get_node(T element) {
    auto* new_node = new LinkedList;
    new_node -> data = element;
    new_node -> prev = nullptr;
    new_node ->next = nullptr;
    return new_node;
}

template <typename T>
void LinkedList<T>:: push_back(T element) {
    static LinkedList *temp;
    if(head == nullptr) {
        head = get_node(element);
        tail = head;
        temp = head;
    } else {
        LinkedList *node = get_node(element);
        tail->next = node;
        tail = node;
        tail->prev = temp;
        temp = temp->next;
    }
}

template <typename T>
void LinkedList<T>:: insert(int position, T element) {
    LinkedList *node = get_node(element);
    if(position == 1){
        head->prev = node;
        node->next = head;
        head = node;
    } else {
        LinkedList *start = head;
        int it = 1;
        while (it < position - 1) {
            start = start->next;
            ++it;
        }
        node->next = start->next;
        node->prev = start;
        start->next = node;
    }
}

template <typename T>
void LinkedList<T>:: pop_bak() {
    LinkedList *temp;
    temp = tail;
    tail = tail->prev;
    tail->next = nullptr;
    delete temp;
}

template <typename T>
void LinkedList<T>:: erase(int position) {
    LinkedList *temp;
    if(position == 1){
        temp = head;
        head = head ->next;
        delete temp;
    } else {
        LinkedList *start = head;
        int it = 1;
        while (it < position - 1) {
            start = start->next;
            ++it;
        }
        if(start->next == tail) {
            temp = tail;
            tail = tail ->prev;
            tail->next = nullptr;
            delete temp;
        } else {
            temp = start -> next;
            start ->next = start ->next->next;
            delete temp;
        }
    }
}

template <typename T>
void LinkedList<T>:: print() {
    LinkedList *start = head;
    while(start != tail->next) {
        cout << start->data << " ";
        start = start->next;
    }
}

int main() {
    LinkedList<int> lt;
    lt.push_back(2);
    lt.push_back(3);
    lt.push_back(4);
    lt.push_back(5);
    lt.insert(1, 56);
    lt.erase(5); // Remove this
    lt.push_back(46); // And this and it works perfectly. Where is the bug?
    lt.pop_bak();
    lt.print();
}

#包括
使用名称空间std；
模板
类链接列表{
私人：
T数据；
LinkedList*prev、*next、*head、*tail；
公众：
LinkedList（）：next（nullptr）、head（nullptr）、tail（nullptr）、prev（nullptr）{
LinkedList*获取节点（T）；
无效推回（T）；
无效插入（int，T）；
void pop_bak（）；
无效擦除（int）；
作废打印（）；
};
模板
LinkedList*LinkedList:：获取节点（T元素）{
auto*new_node=新建链接列表；
新建_节点->数据=元素；
新建_节点->prev=nullptr；
新建节点->下一步=nullptr；
返回新的_节点；
}
模板
void LinkedList:：推回（T元素）{
静态链接列表*temp；
if（head==nullptr）{
head=获取节点（元素）；
尾=头；
温度=水头；
}否则{
LinkedList*节点=获取节点（元素）；
tail->next=节点；
尾=节点；
尾部->上一个=温度；
温度=温度->下一步；
}
}
模板
void LinkedList:：insert（int位置，T元素）{
LinkedList*节点=获取节点（元素）；
如果（位置==1）{
head->prev=节点；
节点->下一步=头部；
头部=节点；
}否则{
LinkedList*开始=头；
int it=1；
同时（它<位置-1）{
开始=开始->下一步；
++它；
}
节点->下一步=开始->下一步；
节点->上一个=开始；
开始->下一步=节点；
}
}
模板
void LinkedList:：pop_bak（）{
LinkedList*temp；
温度=尾部；
tail=tail->prev；
tail->next=nullptr；
删除临时文件；
}
模板
无效链接列表：：擦除（int位置）{
LinkedList*temp；
如果（位置==1）{
温度=水头；
头部=头部->下一步；
删除临时文件；
}否则{
LinkedList*开始=头；
int it=1；
同时（它<位置-1）{
开始=开始->下一步；
++它；
}
如果（开始->下一步==尾部）{
温度=尾部；
tail=tail->prev；
tail->next=nullptr；
删除临时文件；
}否则{
温度=开始->下一步；
开始->下一步=开始->下一步->下一步；
删除临时文件；
}
}
}
模板
作废链接列表：：打印（）{
LinkedList*开始=头；
while（开始！=结束->下一步）{
下一步是收集数据；
}
}
int main（）{
LinkedList lt；
lt.推回（2）；
lt.推回（3）；
lt.推回（4）；
lt.推回（5）；
lt.插入（1，56）；
lt.erase（5）；//删除此
lt.push_back（46）；//还有这个，它工作得很好。臭虫在哪里？
pop_-bak中尉（）；
lt.print（）；
}
解决方案
静态链接列表*temppush_back
中的code>似乎是一个懒惰的黑客。不需要它，而且如果没有它，您的代码会更短：

template <typename T>
void LinkedList<T>::push_back(T element) {
    if (head == nullptr) {
        head = get_node(element);
        tail = head;
    }
    else {
        LinkedList* node = get_node(element);
        tail->next = node;
        node->prev = tail;
        tail = node;
    }
}

现在擦除
delete
s值为5的节点。但是
temp
仍然指向可用的内存1，因此您可以得到：

                        temp (from push_back)
                        |
56 <-> 2 <-> 3 <-> 4    5 [freed]
|                  |
head               tail               

这导致：

                                          temp (from push_back)
         5 [deleted] <-                   |
56 <-> 2 <-> 3 <-> 4 -> 46  -> nullptr    ????  
|                       |
head                    tail               

temp（来自pop_-bak）
|                                   
56 2 3 4->46[已删除]->nullptr 5[已删除]->nullptr
|                                                   |
头尾

正如您看到的，您的列表被完全切碎，您有两个指针指向已释放的内存（例如，您不拥有的包含垃圾数据的内存）。仅仅因为您在
静态LinkedList*temp在
中向后推


在C++中，你使用<代码>删除>代码>而不是C函数<代码>免费>代码>，我引用“释放内存”，因为我认为它更清晰。内存仍然存在，只是不再属于您的程序了
编写一个函数来测试列表的有效性。每次操作后调用此函数。如果列表无效，请调用
abort（）
以进入调试器。最后一次手术是马车手术

首先，只要看看你的代码，我很确定你没有正确地保持你的双链接。我看到你在调整下一个链接，但从来没有调整上一个链接。
这里需要注意的是：考虑将类一分为二（列表和列表节点）。现在任何实例都有两个无用的成员（要么
prev
和
next
要么
head
和
tail
总是
nullptr
）。这也是反直觉的，
get\u node
将返回一个
LinkedList
@churill，请您再具体一点好吗？
void LinkedList<T>::push_back(T element) {
    static LinkedList* temp;
    if (head == nullptr) {...}
    else {
        LinkedList* node = get_node(element);
        tail->next = node;                   
        tail = node;                         
        tail->prev = temp; // prev->temp is now pointing to freed memory
        temp = temp->next; // dereferencing an invalid pointer -> undefined behaviour
    }
}

                                          temp (from push_back)
         5 [deleted] <-                   |
56 <-> 2 <-> 3 <-> 4 -> 46  -> nullptr    ????  
|                       |
head                    tail               

void LinkedList<T>::pop_bak() {
    LinkedList* temp;
    temp = tail;
    tail = tail->prev;    // tail->prev is an invalid pointer, now tail is too
    tail->next = nullptr; // dereferencing invalid pointer (again)
    delete temp;
}

                        temp (from pop_bak)                 
                        |                                   
56 <-> 2 <-> 3 <-> 4 -> 46 [deleted] -> nullptr     5 [deleted] -> nullptr
|                                                   |
head                                                tail