C语言中如何高效展示错误？二进制标志位处理错误是否可取？

我尝试用二进制标志位来做错误处理，觉得这种方式在错误判断时很方便，比如检查FAILURE标志位的逻辑写起来很简单，但问题是这些仅差一位的标志位很容易搞混。

以下是我的代码实现：

# define EXIT_FLAG              0b10000000000000000000000000000000

# define FAILURE                0b00000000000000000001111111111111
# define FAILED_FORK            0b00000000000000000000000000000001
# define FAILED_WAITPID         0b00000000000000000000000000000010
# define FAILED_SEM_OPEN        0b00000000000000000000000000000100
# define FAILED_SEM_CLOSE       0b00000000000000000000000000001000
# define FAILED_SEM_POST        0b00000000000000000000000000010000
# define FAILED_SEM_WAIT        0b00000000000000000000000000100000
# define FAILED_SEM_UNLINK      0b00000000000000000000000001000000
# define FAILED_CREAT_TH        0b00000000000000000000000010000000
# define FAILED_JOIN_TH         0b00000000000000000000000100000000
# define FAILED_KILL            0b00000000000000000000001000000000
# define FAILED_GET_TIME        0b00000000000000000000010000000000
# define FAILED_USLEEP          0b00000000000000000000100000000000
# define FAILED_WRITE           0b00000000000000000001000000000000

# define USERGUIDE              0b00000000000000000010000000000000
# define USERGUIDE_MSG          "usage:\n\t./philo {nb_philos} {die_tm} \
                                {eat_tm} {sleep_tm} (max_eat)\n \
                                \tinputs in ms is capped to 60,000 ms\n"

int ft_putstr_fd(char *s, int fd)
{
    if (s)
    {
        while (*s)
        {
            if (write(fd, s++, 1) == -1)
            {
                write(fd, "Failed write\n", 13);
                return (0);
            }
        }
    }
    return (1);
}

int ft_putstr_error(char *s)
{
    return (ft_putstr_fd(s, STDERR_FILENO));
}

void    *ft_puterror(int flag, void *args)
{
    if (flag & FAILED_FORK)
        ft_putstr_error("Failed fork: ");
    else if (flag & FAILED_WAITPID)
        ft_putstr_error("Failed waitpid: ");
    else if (flag & FAILED_SEM_OPEN)
        ft_putstr_error("Failed sem_open: ");
    else if (flag & FAILED_SEM_CLOSE)
        ft_putstr_error("Failed sem_close: ");
    else if (flag & FAILED_SEM_POST)
        ft_putstr_error("Failed sem_post: ");
    else if (flag & FAILED_SEM_WAIT)
        ft_putstr_error("Failed sem_wait: ");
    else if (flag & FAILED_SEM_UNLINK)
        ft_putstr_error("Failed sem_unlink: ");
    else if (flag & FAILED_CREAT_TH)
        ft_putstr_error("Failed create thread: ");
    else if (flag & FAILED_JOIN_TH)
        ft_putstr_error("Failed joining thread: ");
    else if (flag & FAILED_KILL)
        ft_putstr_error("Failed kill: ");
    else if (flag & FAILED_GET_TIME)
        ft_putstr_error("Failed get_time: ");
    else if (flag & FAILED_USLEEP)
        ft_putstr_error("Failed usleep: ");
    else if (flag & FAILED_WRITE)
        ft_putstr_error("Failed write: ");
    if (flag & FAILURE)
    {
        ft_putstr_error((char *)args);
        ft_putstr_error("\n");
    }
    if (flag & USERGUIDE)
        ft_putstr_error(USERGUIDE_MSG);
    return (NULL);
}

请问是否推荐使用这种二进制标志位的方式处理错误，还是存在更优的最佳实践方案？

这种二进制标志位方案的优缺点 #

优点 #

• 可以同时传递多个错误状态：一次操作触发多个错误时，用位掩码叠加（|操作）就能一次性传递给错误处理函数。
• 错误检查逻辑简洁：用&操作就能快速判断某个错误是否发生。
• 内存开销小：一个32位整数就能存下32种独立错误状态，不需要额外结构体或数组。

缺点 #

• 可读性极差：直接写二进制值（比如0b00000000000000000000000000000010）很难一眼对应到具体错误，后期维护极易混淆——这也是你提到的核心问题。
• 扩展性有限：32位整数最多支持32个独立标志位，后续新增错误类型要么换64位整数，要么重构整个错误体系。
• 无法携带调试细节：比如系统调用返回的errno值、错误发生的具体位置，仅靠标志位没法传递这些对调试至关重要的信息。
• 实现逻辑浪费了位掩码优势：你的ft_puterror用了else if，意味着只能处理一个错误标志，但位掩码本来是支持多错误同时存在的，完全没发挥它的核心价值。

更优的最佳实践方案 #

1. 用枚举替代手动二进制值 #

把错误码定义成枚举，既保留位操作能力，又大幅提升可读性：

typedef enum e_error
{
    ERR_NONE               = 0,
    ERR_FORK               = (1 << 0),
    ERR_WAITPID            = (1 << 1),
    ERR_SEM_OPEN           = (1 << 2),
    ERR_SEM_CLOSE          = (1 << 3),
    // 其他错误码按位左移依次定义
    ERR_FAILURE_MASK       = 0x0001FFFF, // 对应原FAILURE的掩码
    ERR_USERGUIDE          = (1 << 17),
    ERR_EXIT               = (1 << 31)
} t_error;

写ERR_FORK比直接写二进制值清晰太多，也不容易写错位位置。

2. 结合errno传递详细错误信息 #

系统调用失败时会设置全局变量errno，可以把它和错误标志一起传递，让错误日志更有用：

#include <string.h>

void *ft_puterror(t_error flag, int err_no, const char *msg)
{
    if (flag & ERR_FORK)
        ft_putstr_error("Failed fork: ");
    else if (flag & ERR_WAITPID)
        ft_putstr_error("Failed waitpid: ");
    // 其他错误判断逻辑
    if (flag & ERR_FAILURE_MASK)
    {
        if (msg)
            ft_putstr_error((char *)msg);
        if (err_no != 0)
        {
            ft_putstr_error(": ");
            ft_putstr_error(strerror(err_no));
        }
        ft_putstr_error("\n");
    }
    if (flag & ERR_USERGUIDE)
        ft_putstr_error(USERGUIDE_MSG);
    return NULL;
}

调用时直接传errno：

if (fork() == -1)
    return ft_puterror(ERR_FORK, errno, "Could not create child process");

3. 改用独立错误码（非位掩码） #

如果不需要同时传递多个错误，直接用独立整数错误码更简单：

typedef enum e_error_code
{
    ERR_OK = 0,
    ERR_FORK,
    ERR_WAITPID,
    ERR_SEM_OPEN,
    // 依次定义每个错误
    ERR_USERGUIDE,
    ERR_EXIT
} t_error_code;

这种方式逻辑简单，不会出现位操作混淆，还能轻松扩展更多错误类型，错误处理函数直接判断码值即可。

4. 封装错误信息结构体 #

如果需要传递错误发生的文件、行号等上下文，定义错误结构体更合适：

typedef struct s_error
{
    t_error_code code;
    int err_no;
    const char *file;
    int line;
    const char *msg;
} t_error;

void *ft_puterror(t_error err)
{
    char buf[256];
    snprintf(buf, sizeof(buf), "[%s:%d] ", err.file, err.line);
    ft_putstr_error(buf);
    
    switch (err.code)
    {
        case ERR_FORK: ft_putstr_error("Failed fork: "); break;
        case ERR_WAITPID: ft_putstr_error("Failed waitpid: "); break;
        // 其他错误case
        case ERR_USERGUIDE: ft_putstr_error(USERGUIDE_MSG); return NULL;
        default: ft_putstr_error("Unknown error: "); break;
    }
    
    if (err.msg)
        ft_putstr_error((char *)err.msg);
    if (err.err_no != 0)
    {
        ft_putstr_error(": ");
        ft_putstr_error(strerror(err.err_no));
    }
    ft_putstr_error("\n");
    return NULL;
}

用宏简化调用：

#define PUT_ERROR(code, err_no, msg) ft_puterror((t_error){code, err_no, __FILE__, __LINE__, msg})

// 使用示例
if (sem_open(...) == SEM_FAILED)
    return PUT_ERROR(ERR_SEM_OPEN, errno, "Could not open semaphore");

总结 #

你的二进制标志位方案不是不能用，但可读性和扩展性的硬伤很突出，不推荐在大型项目长期使用。如果想保留多错误传递能力，优先用枚举定义位标志；不需要多错误传递的话，独立错误码更简单；需要调试信息时，封装错误结构体是最优选择。

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