C语言函数能否返回结构体数组？现有代码问题求助

嗨，我看了你的代码，问题的核心其实很典型——你在函数里用了栈上的局部数组，函数返回后这些内存就失效了！

具体来说，input_poly里的ex_array1和ex_array2是声明在函数内部的栈局部变量，当函数执行完返回main时，栈上的这些内存会被系统回收复用。这时候main里的指针指向的是已经无效的内存区域，所以除了第一个元素可能因为内存还没被覆盖看起来正常，其余元素都是空值或者乱码，完全不可靠。

下面给你两种解决思路：一种是修复现有代码，另一种是更优的实现方式。

一、修复现有代码的关键步骤 #

1. 把栈数组换成动态内存分配 #

栈内存的生命周期只在函数内部，所以我们需要用malloc在堆上分配内存，这样内存会一直保留到你主动free它。不过首先得修正一个严重的错误：你用sizeof(string1)/2来计算元素个数完全不对，因为string1是指针，sizeof(string1)得到的是指针的大小（32位系统是4字节，64位是8字节），根本不是字符串的长度。

先写一个辅助函数统计每个字符串里的(coef, expo)对数量：

int count_poly_elements(char *str) {
    int cnt = 0;
    float coef;
    int expo;
    int offset = 0;
    int read_len;
    // 循环扫描直到无法读取有效的系数和指数
    while (sscanf(str + offset, "%e %d %n", &coef, &expo, &read_len) == 2) {
        cnt++;
        offset += read_len;
    }
    return cnt;
}

然后在input_poly里替换原来的局部数组：

// 统计两个多项式的元素个数
int size1 = count_poly_elements(string1);
int size2 = count_poly_elements(string2);

// 动态分配堆内存
EXPO *ex_array1 = (EXPO*)malloc(sizeof(EXPO) * (size1));
EXPO *ex_array2 = (EXPO*)malloc(sizeof(EXPO) * (size2));

2. 修正链表尾节点的指针 #

原来的代码里，最后一个元素的ptr_exp会指向数组外的内存（比如ex_array1[size1-1].ptr_exp = &ex_array1[size1]，这已经超出数组范围了），必须把最后一个节点的ptr_exp设为NULL，表示链表结束：

// 处理第一个多项式
count = 0;
offset2 = 0;
while(count < size1) {
    sscanf((string1+offset2),"%e %d %n",&(ex_array1[count]).coef,&(ex_array1[count]).expo,&offset1);
    // 不是最后一个节点的话，指向下一个节点；否则设为NULL
    if (count < size1 - 1) {
        ex_array1[count].ptr_exp = &ex_array1[count+1];
    } else {
        ex_array1[count].ptr_exp = NULL;
    }
    count++;
    offset2 += offset1;
}

// 同理处理第二个多项式
count = 0;
offset4 = 0;
while(count < size2) {
    sscanf((string2+offset4),"%e %d %n",&(ex_array2[count]).coef,&(ex_array2[count]).expo,&offset3);
    if (count < size2 - 1) {
        ex_array2[count].ptr_exp = &ex_array2[count+1];
    } else {
        ex_array2[count].ptr_exp = NULL;
    }
    count++;
    offset4 += offset3;
}

3. 记得在main里释放内存 #

用了malloc就必须手动释放，避免内存泄漏，在main使用完数组后添加：

free(ptr_array[0]);
free(ptr_array[1]);

二、更优的实现方式：直接构建链表 #

其实你不需要先把整行读入字符串再拆分，直接从文件流读取每个(coef, expo)对，逐个分配节点构建链表，这样逻辑更清晰，内存使用也更高效：

1. 编写读取单个多项式的函数 #

EXPO* read_single_poly(FILE *finput) {
    EXPO *head = NULL;
    EXPO *current_tail = NULL;
    float coef;
    int expo;
    
    // 逐个读取系数和指数，直到该行结束
    while (fscanf(finput, "%e %d", &coef, &expo) == 2) {
        // 分配新节点
        EXPO *new_node = (EXPO*)malloc(sizeof(EXPO));
        new_node->coef = coef;
        new_node->expo = expo;
        new_node->ptr_exp = NULL;
        
        // 链接到链表
        if (head == NULL) {
            // 第一个节点，头和尾都指向它
            head = new_node;
            current_tail = new_node;
        } else {
            // 追加到尾部
            current_tail->ptr_exp = new_node;
            current_tail = new_node;
        }
        
        // 跳过当前行剩余的字符，准备读取下一行的多项式
        char c;
        while ((c = fgetc(finput)) != '\n' && c != EOF);
        if (c == '\n') break;
    }
    return head;
}

2. 在main里调用并使用链表 #

int main() {
    FILE *finput = fopen("cp7_in.txt","r");
    if (!finput) { // 别忘了检查文件是否打开成功！
        perror("Failed to open file");
        return 1;
    }
    
    EXPO *poly1 = read_single_poly(finput);
    EXPO *poly2 = read_single_poly(finput);
    
    // 这里可以遍历链表使用数据，比如：
    EXPO *tmp = poly1;
    printf("Polynomial 1:\n");
    while (tmp != NULL) {
        printf("Coef: %.2f, Expo: %d\n", tmp->coef, tmp->expo);
        tmp = tmp->ptr_exp;
    }
    
    // 用完后释放链表内存
    void free_poly(EXPO *head) {
        EXPO *tmp_node;
        while (head != NULL) {
            tmp_node = head;
            head = head->ptr_exp;
            free(tmp_node);
        }
    }
    free_poly(poly1);
    free_poly(poly2);
    fclose(finput);
    return 0;
}

这种方式不需要预先统计元素个数，也避免了复杂的字符串拆分操作，代码可读性和维护性都更好。

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