C++ 以更简洁的方式将项目添加到链表

Question

I'm trying to add items to the front of a list. Basically, what I'm trying to do here is:

• Start with a null list;

• Read a number;

• Call function where a new node is created to store the number, and next pointer points to null;

• If the list is empty, then this new node is the beginning of the list (and only element)

• If there are more elements, then this new node points to the head of the list and becomes the new head.

My function does what I want (at least I can see that in the debugger) but after it returns my list is empty and the head is null again.

struct node{
    int data;
    node *next;
};

void insert_front(node *list, int num){
    node * newnode = new (node);
    newnode->data = num;
    newnode->next = nullptr;

    if (list == nullptr)
        list = newnode;
    else{
        newnode->next = list;
        list = newnode;
    }
}

int main()
{
    int n;
    node *head = nullptr;

    cout << "Input numbers to store (0 finishes input): ";
    cin >> n;
    while (n != 0){
        insert_front(head, n);
        cin >> n;
    }
    return 0;
}

Also tried this but it doesn't even compile:

void insert_front(node &lst, int num){
    node *newnode = new node();
    newnode->data=num;
    newnode->next=lst;
    lst=newnode;
}

I intentionally avoided using OOP, templates, typedef, etc. as much as possible to get a "cleaner" code so I can understand how everything works.

Answer 1

You need a reference to a pointer varibable: node* &list

void insert_front(node* &lst, int num){
    node *newnode = new node();
    newnode->data=num;
    newnode->next=lst;
    lst=newnode;
}

If you don't use a reference you'll be modifying a copy of your "lst" pointer, so the list will keep pointing to the old front after leaving this function. A reference parameter in c++ is prefixed with "&" symbol. In single old C (not your case) you'd need a pointer to a pointer instead.

Answer 2

Don't pass by reference since you can't assign to it.

node* insert_front(node* list, int val)
{
    node* n = new node();
    n->data = val;
    n->next= list;
    return n;  // return the new head of the list
}

Then when inserting:

while (n != 0){
    head = insert_front(head, n);  // head will always change every time you add to the front
    cin >> n;
}

Or alternatively, you can have your insert function also update list to reflect the new head, but you'd have to pass a pointer to the header pointer itself:

void insert_front(node** pList, int val)
{
    node* n = new node();
    n->data = val;
    n->next= *pList;
    *pList= n;
}


while (n != 0){
    insert_front(&head, n);  // head will always change every time you add to the front
    cin >> n;
}

Answer 3

You are passing the list by value.

See this for analogy:

int x;
void modify_x_where_x_is_passed_by_reference( int & x_ref);
void modify_x_where_x_is_passed_by_a_pointer( int * x_ptr);
// Usage
modify_x_where_x_is_passed_by_reference( x );
modify_x_where_x_is_passed_by_a_pointer( &x ); // the address of x

// But when your variable is a pointer!
int * y;
void modify_y_where_y_is_passed_by_reference( int* & y_ref);
void modify_y_where_y_is_passed_by_a_pointer( int* * y_ptr);
// Usage
modify_y_where_y_is_passed_by_reference( y );
modify_y_where_y_is_passed_by_a_pointer( &y ); // the address of y