C语言异常处理机制：setjmp和longjmp的优雅实现

C语言异常处理机制：setjmp和longjmp的优雅实现

一、异常处理的本质

在程序运行过程中，经常会遇到一些非正常情况，如：

• 内存分配失败
• 文件操作错误
• 除数为零
• 数组越界
• 硬件通信失败

这些情况如果不妥善处理，可能导致程序崩溃或行为异常。

二、C语言的异常处理方案

2.1 传统错误处理方式

int func() {
    if (error_condition) {
        return ERROR_CODE;  // 返回错误码
    }
    // 正常逻辑
    return SUCCESS;
}

2.2 setjmp/longjmp机制

#include <setjmp.h>

// 定义跳转缓冲区
jmp_buf env;

// 设置跳转点
if (setjmp(env) == 0) {
    // 正常执行路径
} else {
    // 异常处理路径
}

// 抛出异常
longjmp(env, 1);

三、实现类C++的异常处理

3.1 基础实现

#include <setjmp.h>

// 全局跳转缓冲区
static jmp_buf exception_env;

// 异常类型定义
typedef enum {
    EXCEPTION_NONE = 0,
    EXCEPTION_DIV_ZERO,
    EXCEPTION_NULL_PTR,
    EXCEPTION_OUT_OF_MEMORY
} exception_type_t;

// 异常上下文
typedef struct {
    exception_type_t type;
    const char* message;
    const char* file;
    int line;
} exception_context_t;

static exception_context_t current_exception;

// 异常处理宏
#define TRY if (setjmp(exception_env) == 0)
#define CATCH else
#define THROW(type, msg) do { \
    current_exception.type = type; \
    current_exception.message = msg; \
    current_exception.file = __FILE__; \
    current_exception.line = __LINE__; \
    longjmp(exception_env, 1); \
} while(0)

3.2 使用示例

double safe_divide(double a, double b)
{
    if (b == 0.0) {
        THROW(EXCEPTION_DIV_ZERO, "Division by zero");
    }
    return a / b;
}

void test_exception(void)
{
    TRY {
        printf("Attempting division...\n");
        double result = safe_divide(10.0, 0.0);
        printf("Result: %f\n", result);
    }
    CATCH {
        printf("Exception caught at %s:%d\n", 
               current_exception.file,
               current_exception.line);
        printf("Error: %s\n", current_exception.message);
    }
}

四、高级特性实现

4.1 嵌套异常处理

#define MAX_EXCEPTION_DEPTH 32

typedef struct {
    jmp_buf env;
    exception_context_t context;
} exception_frame_t;

static struct {
    exception_frame_t frames[MAX_EXCEPTION_DEPTH];
    int depth;
} exception_stack = {0};

#define TRY_NESTED \
    exception_stack.depth++; \
    if (setjmp(exception_stack.frames[exception_stack.depth-1].env) == 0)

#define CATCH_NESTED \
    else; \
    exception_stack.depth--

4.2 资源自动清理

typedef void (*cleanup_handler_t)(void*);

typedef struct {
    cleanup_handler_t handler;
    void* context;
} cleanup_item_t;

#define MAX_CLEANUP_ITEMS 16
static cleanup_item_t cleanup_stack[MAX_CLEANUP_ITEMS];
static int cleanup_count = 0;

#define CLEANUP_PUSH(func, ctx) do { \
    cleanup_stack[cleanup_count].handler = func; \
    cleanup_stack[cleanup_count].context = ctx; \
    cleanup_count++; \
} while(0)

#define CLEANUP_POP() do { \
    if (cleanup_count > 0) { \
        cleanup_count--; \
        if (cleanup_stack[cleanup_count].handler) { \
            cleanup_stack[cleanup_count].handler( \
                cleanup_stack[cleanup_count].context); \
        } \
    } \
} while(0)

五、实际应用示例

5.1 文件操作异常处理

void process_file(const char* filename)
{
    FILE* fp = NULL;
    char* buffer = NULL;
    
    TRY {
        // 打开文件
        fp = fopen(filename, "r");
        if (!fp) {
            THROW(EXCEPTION_FILE_ERROR, "Failed to open file");
        }
        
        // 分配内存
        buffer = malloc(1024);
        if (!buffer) {
            THROW(EXCEPTION_OUT_OF_MEMORY, "Memory allocation failed");
        }
        
        // 处理文件...
        
    } CATCH {
        // 清理资源
        if (buffer) free(buffer);
        if (fp) fclose(fp);
        
        // 处理异常
        printf("Error: %s\n", current_exception.message);
    }
}

5.2 硬件通信异常处理

bool i2c_transfer(uint8_t addr, uint8_t* data, size_t len)
{
    TRY {
        // 启动I2C传输
        if (!i2c_start()) {
            THROW(EXCEPTION_HW_ERROR, "I2C start failed");
        }
        
        // 发送地址
        if (!i2c_send_addr(addr)) {
            THROW(EXCEPTION_HW_ERROR, "I2C address failed");
        }
        
        // 发送数据
        for (size_t i = 0; i < len; i++) {
            if (!i2c_send_byte(data[i])) {
                THROW(EXCEPTION_HW_ERROR, "I2C data transfer failed");
            }
        }
        
        return true;
        
    } CATCH {
        i2c_stop();  // 确保总线释放
        return false;
    }
}

六、最佳实践建议

1. 合理使用场景

   • 用于真正的异常情况
   • 不要用于正常的控制流程
   • 避免过度使用

2. 资源管理

   • 确保异常发生时资源正确释放
   • 使用cleanup机制自动管理资源
   • 避免资源泄漏

3. 异常粒度

   • 合理划分异常类型
   • 提供有意义的错误信息
   • 记录异常发生位置

七、总结

setjmp/longjmp提供了在C语言中实现异常处理的可能性。通过合理的封装和使用，我们可以实现类似C++的异常处理机制，使代码更加健壮和优雅。但要注意，这种机制应该谨慎使用，并确保正确处理资源清理问题。