C语言：如何从函数返回结构体指针数组及复制链表返回头尾指针

一、技术问题：如何在C语言中从函数返回结构体指针数组？ #

在C里直接返回栈上的局部数组是绝对不行的——函数执行完毕后，栈帧会被销毁，数组占用的内存会被系统回收，返回的指针会变成“野指针”，访问它会导致未定义行为。所以我们有几种靠谱的实现方式：

1. 用动态分配的数组（malloc）返回 #

你可以在函数内部用malloc分配数组内存，然后返回这个动态数组的指针。但要注意，调用者必须记得用free释放内存，避免内存泄漏：

struct path **returnPtrArray() {
    // 分配能存2个结构体指针的数组
    struct path **arr = malloc(2 * sizeof(struct path *));
    // 初始化数组元素（示例）
    arr[0] = malloc(sizeof(struct path));
    arr[1] = malloc(sizeof(struct path));
    return arr;
}

调用后要记得释放：

struct path **myArr = returnPtrArray();
// 使用数组...
// 先释放每个指针指向的内存
free(myArr[0]);
free(myArr[1]);
// 再释放数组本身
free(myArr);

2. 让调用者提供数组，函数负责填充 #

这种方式不需要动态分配，函数接收调用者传入的数组指针，直接把结果写入数组：

void fillPtrArray(struct path **resultArr) {
    resultArr[0] = malloc(sizeof(struct path));
    resultArr[1] = malloc(sizeof(struct path));
}

调用时：

struct path *myArr[2];
fillPtrArray(myArr);
// 使用数组...

3. 用结构体封装多个指针（最推荐） #

如果返回的指针数量固定（比如你的场景里是头和尾两个指针），用结构体封装比数组更清晰，可读性更强，也避免了数组的一些坑：

typedef struct {
    struct path *head;
    struct path *tail;
} PathPair;

PathPair getPathPair() {
    PathPair pair;
    pair.head = malloc(sizeof(struct path));
    pair.tail = malloc(sizeof(struct path));
    return pair;
}

这种方式调用起来非常直观，也不需要担心内存管理的额外坑（只要记得释放内部的指针就行）。

二、场景需求：实现copyPath函数返回新链表的头和尾 #

回到你的代码，里面的struct path *resultPath[2]是栈上的局部数组，绝对不能返回——函数结束后这个数组就失效了。下面给你两种可行的实现方案：

方案1：用结构体封装返回值（最推荐） #

先定义一个封装头和尾的结构体，然后让copyPath返回这个结构体：

#include <stdlib.h>

// 假设你的path结构体定义如下（根据实际字段调整）
struct path {
    int data; // 示例数据字段
    struct path *next;
};

// 封装头和尾的结构体
typedef struct {
    struct path *head;
    struct path *tail;
} PathPair;

PathPair copyPath(struct path *head) {
    PathPair result = {NULL, NULL}; // 初始化结果为NULL
    struct path *current = head;

    while (current != NULL) {
        // 为新节点分配内存
        struct path *newNode = malloc(sizeof(struct path));
        if (!newNode) {
            // 内存分配失败，这里可以添加错误处理（比如释放已分配的节点）
            return result; // 提前返回，此时可能已有部分节点被分配
        }

        // 复制原节点的数据（根据实际结构体字段调整）
        newNode->data = current->data;
        newNode->next = NULL;

        if (!result.head) {
            // 第一个节点，同时作为头和尾
            result.head = newNode;
            result.tail = newNode;
        } else {
            // 将新节点添加到链表尾部
            result.tail->next = newNode;
            result.tail = newNode;
        }

        current = current->next;
    }

    return result;
}

调用示例：

// 假设originalHead是原链表的头指针
PathPair newPath = copyPath(originalHead);
// 使用newPath.head和newPath.tail...
// 记得用完后释放整个新链表
struct path *temp = newPath.head;
while (temp != NULL) {
    struct path *next = temp->next;
    free(temp);
    temp = next;
}

方案2：通过指针参数返回头和尾 #

如果你不想新增结构体类型，可以让调用者传入两个指针的地址，函数内部直接修改这两个指针的值：

#include <stdlib.h>

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

void copyPath(struct path *head, struct path **newHead, struct path **newTail) {
    *newHead = NULL;
    *newTail = NULL;
    struct path *current = head;

    while (current != NULL) {
        struct path *newNode = malloc(sizeof(struct path));
        if (!newNode) {
            // 错误处理逻辑
            return;
        }

        newNode->data = current->data;
        newNode->next = NULL;

        if (!*newHead) {
            *newHead = newNode;
            *newTail = newNode;
        } else {
            (*newTail)->next = newNode;
            *newTail = newNode;
        }

        current = current->next;
    }
}

调用示例：

struct path *newHead, *newTail;
copyPath(originalHead, &newHead, &newTail);
// 使用newHead和newTail...
// 释放链表的逻辑和之前一样

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