如何在仅返回int类型的函数外部访问其中创建的链表头

这问题我碰到过好多次了，给你梳理几个实用的解决方案，每个方案的优缺点我都讲清楚，方便你按需选择：

1. 使用输出参数（指针的指针）—— 最推荐的规范方案 #

这是工业界最常用的做法，核心思路是：把存储链表头节点地址的指针的地址作为参数传给函数，函数内部直接修改这个外部指针的值，同时用返回的int传递状态（比如链表长度、成功/失败码）。

举个C语言的示例代码：

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

// 定义链表节点结构
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 返回值：正数=链表长度，-1=参数错误，0=内存分配失败
int createLinkedList(Node** head_out) {
    // 先校验参数合法性
    if (head_out == NULL) {
        return -1;
    }

    // 创建头节点
    Node* head = (Node*)malloc(sizeof(Node));
    if (head == NULL) {
        return 0;
    }
    head->data = 1;
    head->next = NULL;

    // 添加第二个节点
    Node* second = (Node*)malloc(sizeof(Node));
    if (second == NULL) {
        free(head); // 分配失败时清理已申请的内存，避免泄漏
        return 0;
    }
    second->data = 2;
    second->next = NULL;
    head->next = second;

    // 将内部创建的链表头地址赋值给外部传入的指针
    *head_out = head;

    return 2; // 返回链表的节点数量
}

// 使用示例
int main() {
    Node* my_list = NULL;
    int result = createLinkedList(&my_list);

    if (result > 0) {
        // 此时my_list就是函数内创建的链表头节点，可直接操作
        Node* current = my_list;
        printf("链表内容：");
        while (current != NULL) {
            printf("%d ", current->data);
            current = current->next;
        }
        printf("\n");

        // 记得用完后释放内存，避免泄漏
        current = my_list;
        while (current != NULL) {
            Node* temp = current;
            current = current->next;
            free(temp);
        }
    } else if (result == -1) {
        printf("参数错误！\n");
    } else {
        printf("内存分配失败！\n");
    }
    return 0;
}

这个方案的优势：

• 完全没有全局/静态变量的副作用，线程安全
• 内存管理逻辑清晰，分配失败时可以及时清理已申请的内存
• 返回的int可以灵活传递各种状态信息，实用性强

2. 使用静态全局变量—— 应急但不推荐的方案 #

如果你实在没办法用输出参数（比如函数签名被硬性要求不能改），可以用静态全局变量存储链表头节点。但这个方案有不少坑，得谨慎用。

示例代码：

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

typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 静态全局变量，仅当前文件可见
static Node* static_list_head = NULL;

// 返回值：正数=链表长度，0=内存分配失败
int createLinkedList() {
    // 先清理之前的链表，否则会造成内存泄漏
    Node* current = static_list_head;
    while (current != NULL) {
        Node* temp = current;
        current = current->next;
        free(temp);
    }
    static_list_head = NULL;

    // 创建新链表
    static_list_head = (Node*)malloc(sizeof(Node));
    if (static_list_head == NULL) {
        return 0;
    }
    static_list_head->data = 1;
    static_list_head->next = NULL;

    Node* second = (Node*)malloc(sizeof(Node));
    if (second == NULL) {
        free(static_list_head);
        static_list_head = NULL;
        return 0;
    }
    second->data = 2;
    second->next = NULL;
    static_list_head->next = second;

    return 2;
}

// 使用示例
int main() {
    int len = createLinkedList();
    if (len > 0) {
        Node* current = static_list_head;
        // 操作链表...
        // 用完后记得清理，不然下次调用函数会泄漏内存
    }
    return 0;
}

这个方案的缺点：

• 线程不安全：多线程环境下同时调用函数会导致数据混乱
• 多次调用函数会覆盖之前的链表，除非每次调用前手动清理
• 内存泄漏风险高：如果忘记清理静态变量里的链表，内存会一直占用

3. 使用全局变量—— 尽量避免 #

和静态全局变量类似，但全局变量的作用域是整个程序，更容易被其他代码意外修改，副作用更强，除非是极端场景，否则绝对不推荐使用。

优先选择**输出参数（指针的指针）**的方案，这是最符合良好编程实践的做法，既能满足函数返回int的要求，又能安全地获取内部创建的链表头节点，还没有额外的副作用。

内容的提问来源于stack exchange，提问作者Jakub Malý