链表根指针传入头文件函数后变动，如何保持其恒定？

Great question! The core issue here is that in C, function arguments are passed by value. When you pass your root pointer to append, the function gets a copy of that pointer—so modifying the copy (ROOT inside the function) doesn't change the original root in main unless you send the updated pointer back and reassign it.

Luckily, there are two clean ways to avoid having to reassign root every time you call append:

1. Use a Pointer to a Pointer (Double Pointer) #

Instead of passing the root pointer directly, pass a pointer to the root pointer. This lets the function modify the original pointer in main directly, no return value needed.

Modified append Function: #

/* Append value to the end of the list, modifies the root pointer directly */
void append(struct node** ROOT, int d){
    struct node *temp = (struct node*)malloc(sizeof(struct node));
    temp->data = d;
    temp->link = NULL;

    if(*ROOT == NULL){
        // If list is empty, update the original root pointer
        *ROOT = temp;
    } else {
        struct node *p = *ROOT;
        while(p->link != NULL){
            p = p->link;
        }
        p->link = temp;
    }
}

Updated main Code: #

#include "singly_linked_list0.h"
struct node* root = NULL;

int main(){
    int n = 5;
    while(n > 0){
        // Pass address of root pointer
        append(&root, n);
        n--;
    }
    print_all(root);
    return 0;
}

This works because *ROOT directly refers to the original root variable in main—so when we assign *ROOT = temp, we're updating the actual root pointer, not a copy.

2. Wrap the Linked List in a Struct (More Scalable) #

For larger projects, it's often cleaner to encapsulate the entire linked list in a struct. This lets you include additional metadata (like list length) and makes functions easier to work with, as you just pass a pointer to the list struct.

Step 1: Define the List Struct in Your Header #

typedef struct node {
    int data;
    struct node* link;
} Node;

typedef struct linked_list {
    Node* root;
    // Optional: Add other fields like int length;
} LinkedList;

Step 2: Modified append Function #

/* Append value to the linked list */
void append(LinkedList* list, int d){
    Node *temp = (Node*)malloc(sizeof(Node));
    temp->data = d;
    temp->link = NULL;

    if(list->root == NULL){
        list->root = temp;
    } else {
        Node *p = list->root;
        while(p->link != NULL){
            p = p->link;
        }
        p->link = temp;
    }
    // Optional: increment list->length here
}

Updated main Code #

#include "singly_linked_list0.h"

int main(){
    LinkedList list = {.root = NULL}; // Initialize empty list
    int n = 5;
    while(n > 0){
        append(&list, n);
        n--;
    }
    print_all(list.root);
    return 0;
}

This approach is more maintainable—if you ever need to add more functionality to your list (like inserting at the start, deleting nodes), you can work with the LinkedList struct instead of juggling individual pointers.

Note on Your Original Approach #

Just to clarify: your original code isn't "wrong"—it's a valid way to handle the linked list. The methods above just eliminate the need for repeated reassignment, making the code a bit cleaner and more intuitive.

内容的提问来源于stack exchange，提问作者Yasir