c++ - 使用类的链表

Question

我有一个代码，它似乎可以工作，但我无法获取存储在第一个节点和最后一个节点之间的链表中的值，是否跳过了中间的指针？取消引用这些跳过的指针会给我一个段错误，这是代码

#include<iostream>
#include <new>
using namespace std;

class list{ 
    int value;
    list* next;

public:    
    list(int a=0, list* b=0) {value=a;next=b;}    
    //~list() {delete next;}
    void newnode(int a, list* tmp) {
        tmp->next=new list;
        tmp=tmp->next;
        cout<<"Address of next: "<<tmp<<'\n';
        tmp->value=a;
    }

    void printlist (list* regist){
        list* tmp;
        tmp=regist; 
        cout<<tmp->value<<'\n';

        while(tmp->next != 0){
            tmp=tmp->next;
            cout<<tmp->value<<'\n';
            cout<<"Address of next: "<<tmp<<'\n';   
        }
    }
};

int main() {
    int first;    
    cout<<"Enter value for origin: \n";
    cin>>first; 
    list* root=new list(first);
    list* tpo=root;
    cout<<"How many numbers to add? \n";

    int choice;
    cin>>choice;

    int num;
    while(choice) {
        cout<<"Enter value: \n";
        cin>>num;    
        root->newnode(num, tpo);
        choice--;  
    }

    cout<<"Do you want me to show you these values, type 1 for yes and 0 for no: \n";
    cin>>choice;

    if(choice) {
        root->printlist(root);
    }
}

1. 在打印值时，为什么它会跳过这些指针（节点）？
2. 节点之间的中间是否被指向被破坏？如果是这样，评论析构函数应该可以解决问题，对吗？

我究竟做错了什么？

Answer 1

您总是提交root给 newnode （原样分配给tpo），从而导致一个包含两个元素和任意数量的泄漏内存的列表

Answer 2

1）当您要求更多值时，您总是会覆盖列表中的第二个元素。您需要将newnode()' 签名更改为newnode(int a, list*& tmp).

稍后编辑：另一种方法是具有以下签名list* newnode(int a, list* tmp)，并在函数结束时使用return tmp;. 然后，在主循环中，您将拥有tpo = root->newnode(num, tpo);. 这种方式tpo总是指向下一个元素。

2）此外，释放 memorylist的析构函数不应该做任何特别的事情。我会说你在你的类中创建了一个删除列表的静态方法。像这样的东西：

public: static void deleteList(list*& root) { list* tmp = root; while (tmp) { tmp = root->next; delete root; root = NULL; root = tmp; } };

并称它为list::deleteList(root);

Answer 3

链表的全面实现，请查看以下链接：

http://www.bitsbyta.com/2011/02/how-to-add-node-at-end-of-linked-list-c.html