C语言跨文件函数间基于链表的错误通信问题求解

1. 给错误链表加状态标记 #

修改错误链表结构，在链表头部新增状态字段，专门记录错误链表自身的异常（比如内存分配失败）。函数尝试添加错误节点失败时，直接更新这个状态，上层调用后先检查状态就能获知问题。

示例代码：

// 定义错误链表的状态枚举
typedef enum {
    ERR_LIST_NORMAL,
    ERR_LIST_OUT_OF_MEM
} ErrListStatus;

// 单个错误节点
typedef struct ErrorNode {
    char *msg;
    struct ErrorNode *next;
} ErrorNode;

// 错误链表的头部（包含状态）
typedef struct ErrorList {
    ErrorNode *head;
    ErrListStatus status;
} ErrorList;

// 示例函数：向链表添加错误
int foo(int x, ErrorList *err_list) {
    // 函数要返回的业务值
    int result = 0;

    // 模拟业务错误，尝试添加错误节点
    ErrorNode *new_node = malloc(sizeof(ErrorNode));
    if (!new_node) {
        // 标记链表自身的内存分配失败
        err_list->status = ERR_LIST_OUT_OF_MEM;
        return result;
    }
    new_node->msg = "NAME_NOT_VALID";
    new_node->next = err_list->head;
    err_list->head = new_node;

    // 可继续添加其他错误...

    return result;
}

// 上层调用示例
int main() {
    ErrorList err_list = {NULL, ERR_LIST_NORMAL};
    int res = foo(10, &err_list);
    if (err_list.status == ERR_LIST_OUT_OF_MEM) {
        puts("Failed to allocate error node");
    }
    // 处理其他业务逻辑和错误消息
    return 0;
}

2. 使用固定大小的错误缓冲区替代链表 #

放弃动态链表，改用预分配的数组作为错误缓冲区，避免运行时动态分配内存的问题。缓冲区有固定的最大错误数限制，超出时标记溢出即可。这种实现简单，无内存分配失败风险（只要初始化阶段分配好）。

示例代码：

#define MAX_ERROR_COUNT 50

typedef struct ErrorBuffer {
    char *msgs[MAX_ERROR_COUNT];
    int count;
    int overflow; // 标记是否超出最大错误数
} ErrorBuffer;

int bar(int x, ErrorBuffer *err_buf) {
    int result = 0;

    // 添加第一个错误
    if (err_buf->count < MAX_ERROR_COUNT) {
        // 建议用静态字符串避免额外内存分配
        err_buf->msgs[err_buf->count++] = "FILE_OPENING_FAILED";
    } else {
        err_buf->overflow = 1;
    }

    // 添加第二个错误
    if (err_buf->count < MAX_ERROR_COUNT) {
        err_buf->msgs[err_buf->count++] = "MEMORY_ALLOCATION_FAILED";
    } else {
        err_buf->overflow = 1;
    }

    return result;
}

3. 预分配错误节点内存池 #

在程序初始化阶段，预先分配一批错误节点的内存池，后续添加错误时直接从池里取节点，不用动态malloc。只要池的大小足够覆盖预期错误数量，就不会出现分配失败；如果池耗尽，标记即可。

示例代码：

#define ERROR_POOL_SIZE 30
static struct ErrorNode {
    char *msg;
    struct ErrorNode *next;
} error_pool[ERROR_POOL_SIZE];
static int pool_idx = 0;

// 从内存池获取一个节点
struct ErrorNode* get_error_node() {
    if (pool_idx >= ERROR_POOL_SIZE) {
        return NULL;
    }
    return &error_pool[pool_idx++];
}

int baz(int x, struct ErrorNode **err_list) {
    int result = 0;

    struct ErrorNode *new_node = get_error_node();
    if (!new_node) {
        // 内存池耗尽，上层可通过检查新增节点是否成功判断
        return result;
    }
    new_node->msg = "NAME_NOT_VALID";
    new_node->next = *err_list;
    *err_list = new_node;

    return result;
}

4. 全局致命错误标记（谨慎使用） #

定义一个全局变量标记严重错误（比如错误节点分配失败），函数在分配失败时设置这个变量，上层调用后检查。注意这个方法在多线程环境下需要加同步机制（比如原子操作、互斥锁），且全局变量易引发耦合，仅适合简单场景。

示例代码：

#include <stdatomic.h>

// 原子变量保证多线程安全
static atomic_int g_fatal_err = 0;

int qux(int x, struct ErrorNode **err_list) {
    int result = 0;

    struct ErrorNode *new_node = malloc(sizeof(struct ErrorNode));
    if (!new_node) {
        atomic_store(&g_fatal_err, 1);
        return result;
    }
    new_node->msg = "MEMORY_ALLOCATION_FAILED";
    new_node->next = *err_list;
    *err_list = new_node;

    return result;
}

// 上层调用
int main() {
    struct ErrorNode *err_list = NULL;
    int res = qux(5, &err_list);
    if (atomic_load(&g_fatal_err)) {
        puts("Fatal error: failed to allocate error node");
    }
    return 0;
}

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