c++ - 为什么我的类节点会覆盖自身而不是创建一个新的节点对象

Question

有人可以运行这段代码并告诉我为什么插入的节点不断被覆盖吗？

#ifndef LinkedList_hpp
#define LinkedList_hpp

#include <stdio.h>
#include <utility>

template<class T>class LinkedList{
public:
LinkedList(){
        head = nullptr;
        tail = nullptr;
        size = 0;
    }
    //void insert(T val);
    class Node{
        public:
        Node* next;
        T* value;
        Node* prev;
        Node(T* value){
            this->value = value;
        }
        Node(){
        }
        Node(T* value,Node* prev, Node* next){
            this->value = value;
            this->next = next;
            this->prev = prev;
        }
        Node* operator=(const Node& node){
            this->value = node.value;
            this->prev = node.prev;
            this->next = node.next;
            return *this;
        }

    };
public:
    Node* head;
    Node* tail;
    int size;
    void insert(T val){

在这一行，如果前一个 head 是 10，则当前 val 40 覆盖旧的 head 值并插入一个 val 40 的新节点

        Node* temp = new Node(&val);
        if(head==nullptr){
            head = temp;
            tail = temp;
        }else{
            temp->next = head;
            head->prev = temp;
            head = temp;
        }
        size++;
    }
#endif

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

int main(int argc, const char * argv[]) {

   // LinkedList<int> t;
    int h = 7;
    int j = 10;
    int k = 40;
    LinkedList<int>* list1 = new LinkedList<int>();


    list1->insert(h);
    list1->insert(j);
    list1->insert(k);

return 0;
}

每次调用 insert 并构造一个新节点时，它会覆盖旧值，一切都变成当前 Val

Answer 1

void insert(T val){

val 是此函数的参数。这个对象，这个 val，只存在于这个函数返回之前。此时它被销毁，就像在函数内部的非静态范围内声明的所有其他内容一样。这就是 C++ 的工作原理。一旦 insert() 返回，这个 val 就不再存在了。它不复存在了。它去见它的制造者。它成为一个前对象，不再存在并且完全在过去。

您的 insert() 函数执行以下操作:

Node* temp = new Node(&val);

您将指向此 val 参数的指针传递给 Node 的构造函数，然后 Node 将指向参数的指针保存到insert()，作为它自己的类成员。

太好了，但是一旦 insert() 返回，new 中保存的指针 Node 就变成指向销毁对象，并且取消引用此指针成为未定义的行为。

然后，您稍后会尝试取消引用原始指针，该指针不再指向有效对象。

这解释了在您的代码中观察到的未定义行为。

归根结底，您的类和模板的设计存在根本性缺陷。 Node 使用指针没有明显的目的。 Node 应该简单地将 T 存储为它自己的类成员，作为 value，而不是 value 是指向的指针一些其他的 T 存在于某处，并且可以随时被销毁，不受 Node 的控制。

所示代码中的另一个问题是 Node 的两个构造函数无法初始化指向 的 next 和 prev 指针空。这也会导致未定义的行为。