C语言链表Append函数失效：调用后主函数表头仍为NULL

问题重现 #

你编写的链表append函数在内部能正确修改表头指针，但主函数中的表头指针始终为NULL，相关代码如下：

节点类型定义 #

typedef struct node {
    int value;
    struct node* next;
} node;

append函数 #

void append(node* header, node newNode) {
    // 检查表头是否为空，为空则添加第一个节点
    if (header == NULL) {
        header = &newNode;
        printf("List val: %p\n", header);
        printf("node address: %p\n\n", &newNode);
    } else {
        // 找到最后一个节点
        node* tmp = header;
        while (tmp -> next != NULL) {
            tmp = tmp -> next;
        }
        // 将新节点地址赋值给最后一个节点的next
        tmp -> next = &newNode;
    }
}

main函数调用 #

node* list = NULL;
node a = {1, NULL};
append(list, a);
printf("%p\n", list);
printf("%p\n", &a);

输出结果 #

List val: 000000b6779ff900
node address: 000000b6779ff900

0000000000000000
000000b6779ff970

核心问题分析 #

你的代码存在两个致命问题：

1. 指针的值传递导致主函数指针未被修改 #

C语言中所有函数参数都是值传递，你传递的list是一个指针变量，函数内的header只是它的副本。修改header = &newNode仅仅改变了副本的指向，主函数中的list完全不受影响，所以调用后还是NULL。

要修改主函数中的指针变量，必须传递指针的指针（二级指针），让函数能直接操作主函数里的指针地址。

2. 传递节点值导致局部副本地址失效 #

你传递的是node newNode，这是值传递，函数内的newNode是主函数中a的局部拷贝。函数执行完毕后，这个局部拷贝会被销毁，你把它的地址存入链表，后续访问会变成野指针，行为完全不可预测。

正确的做法要么传递外部节点的指针，要么在函数内动态分配内存（malloc）来创建新节点。

修正方案 #

方案1：传递二级指针与节点指针 #

这种方案适用于使用栈上已存在的节点：

#include <stdio.h>

typedef struct node {
    int value;
    struct node* next;
} node;

void append(node** header, node* newNode) {
    // 确保新节点的next为空，避免链表混乱
    newNode->next = NULL;
    
    if (*header == NULL) {
        // 修改主函数中的表头指针
        *header = newNode;
        printf("List val: %p\n", *header);
        printf("node address: %p\n\n", newNode);
    } else {
        node* tmp = *header;
        while (tmp->next != NULL) {
            tmp = tmp->next;
        }
        tmp->next = newNode;
    }
}

int main() {
    node* list = NULL;
    node a = {1, NULL};
    // 传递表头指针的地址和节点a的地址
    append(&list, &a);
    printf("%p\n", list);
    printf("%p\n", &a);
    return 0;
}

运行后，主函数的list会正确指向节点a的地址，输出不再是NULL。

方案2：动态分配内存创建节点 #

这种方案适用于需要长期存在的节点（堆内存），避免栈变量销毁的问题：

#include <stdio.h>
#include <stdlib.h>

typedef struct node {
    int value;
    struct node* next;
} node;

void append(node** header, int value) {
    // 动态分配内存创建新节点
    node* newNode = (node*)malloc(sizeof(node));
    if (newNode == NULL) {
        perror("malloc failed");
        return;
    }
    newNode->value = value;
    newNode->next = NULL;
    
    if (*header == NULL) {
        *header = newNode;
    } else {
        node* tmp = *header;
        while (tmp->next != NULL) {
            tmp = tmp->next;
        }
        tmp->next = newNode;
    }
}

// 辅助函数：遍历链表并释放内存
void free_list(node** header) {
    node* tmp;
    while (*header != NULL) {
        tmp = *header;
        *header = (*header)->next;
        free(tmp);
    }
}

int main() {
    node* list = NULL;
    append(&list, 1);
    append(&list, 2);
    
    // 遍历打印链表
    node* tmp = list;
    while (tmp != NULL) {
        printf("%d ", tmp->value);
        tmp = tmp->next;
    }
    printf("\n");
    
    // 释放链表内存
    free_list(&list);
    return 0;
}

注意：动态分配的内存必须手动释放，否则会造成内存泄漏。

关键总结 #

• 要修改主函数中的指针，必须传递二级指针（指针的指针），因为C是值传递。
• 禁止将函数局部变量的地址存入链表，否则会产生野指针。
• 使用堆内存创建节点时，记得在链表不再使用时释放所有节点的内存。

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