用 C 语言实现 try-except-finally：基于 setjmp/longjmp 的异常处理机制

2023-06-29更新于 2026-10-02约 6 分钟0 阅读问问 AI

背景

C 语言没有内置异常机制，错误传播通常依赖返回值或全局错误码，调用链一长就容易丢失上下文。1989 年 DEC 的 Robert Roberts 基于 Modula-2+ 的异常模型，用 setjmp/longjmp 实现了一套可移植的 try-except-finally 宏，核心思路是：在 TRY 块入口保存栈帧，异常发生时沿上下文链表向上查找匹配的 EXCEPT 子句，找到后 longjmp 回跳。

下面按头文件、实现文件、测试程序三部分走读源码，最后说明执行流程和需要注意的边界。

头文件：宏展开与上下文结构

text

/* Copyright 1989 Digital Equipment Corporation.                          */
/* Distributed only by permission.                                        */
/**************************************************************************/
/* File: exception.h                                                      */
/* Last modified on Wed Mar 15 16:40:41 PST 1989 by roberts               */
/*                                                                        */
/* The exception package provides a general exception handling mechanism  */
/* for use with C that is portable across a variety of compilers and      */
/* operating systems. The design of this facility is based on the         */
/* exception handling mechanism used in the Modula-2+ language at DEC/SRC */
/* and is described in detail in the paper in the documents directory.    */
/* For more background on the underlying motivation for this design, see  */
/* SRC Research Report #3.                                                */
/**************************************************************************/

#include <setjmp.h>
#include <stdlib.h>

#define MaxExceptionsPerScope 10
#define ETooManyExceptClauses 101
#define EUnhandledException   102

#define ES_Initialize 0
#define ES_EvalBody   1
#define ES_Exception  2

typedef struct { char *name ;} exception;

typedef struct _ctx_block {
    jmp_buf jmp;
    int nx;
    exception *array[MaxExceptionsPerScope];
    exception *id;
    int value;
    int finally;
    struct _ctx_block *link;
} context_block;

extern exception ANY;
extern context_block *exceptionStack;
extern void _RaiseException(exception *e, int v);

#define RAISE(e, v) _RaiseException(&e, v)

#define TRY \
    {\
        context_block _ctx;\
        int _es = ES_Initialize;\
        _ctx.nx = 0;\
        _ctx.link= NULL;\
        _ctx.finally = 0;\
        _ctx.link = exceptionStack;\
        exceptionStack = &_ctx;\
        if (setjmp(_ctx.jmp) != 0) _es = ES_Exception;\
        while (1) {\
            if (_es == ES_EvalBody) {

#define EXCEPT(e) \
                if(_es == ES_EvalBody)  exceptionStack = _ctx.link;\
                break;\
            }\
            if (_es == ES_Initialize) {\
                if (_ctx.nx >= MaxExceptionsPerScope)\
                    exit(ETooManyExceptClauses);\
                _ctx.array[_ctx.nx++] = &e;\
            } else if (_ctx.id == &e || &e == &ANY) {\
                int exception_value = _ctx.value;\
                exceptionStack = _ctx.link;

#define FINALLY \
            }\
            if (_es == ES_Initialize) {\
                if (_ctx.nx >= MaxExceptionsPerScope)\
                    exit(ETooManyExceptClauses);\
                _ctx.finally = 1;\
            } else {\
                exceptionStack = _ctx.link;

#define ENDTRY \
                if (_ctx.finally && _es == ES_Exception)\
                    _RaiseException(_ctx.id, _ctx.value);\
                break;\
            }\
            _es = ES_EvalBody;\
        }\
    }

几个关键点：

context_block 是异常上下文，包含 jmp_buf（保存跳转目标）、已注册的异常类型数组、当前异常 id/value、是否含 FINALLY 子句，以及指向外层上下文的 link 指针，形成一条链。
exceptionStack 是全局链表头，指向最内层上下文。每次 TRY 展开时把新节点压入链头。
TRY / EXCEPT / FINALLY / ENDTRY 四个宏拼在一起构成一个 while(1) 循环，用 _es 状态变量（ES_Initialize → ES_EvalBody → ES_Exception）控制流程：
- 第一次进入（ES_Initialize）：注册 EXCEPT/FINALLY 子句，然后置 _es = ES_EvalBody 进入正体。
- 正体执行完毕（ES_EvalBody）：弹出上下文，break 退出循环。
- 被 longjmp 唤醒（ES_Exception）：匹配异常类型，执行对应子句；若含 FINALLY 且异常未被捕获，FINALLY 执行完后重新 RAISE 继续向上传播。

实现文件：_RaiseException

text

/* Copyright 1989 Digital Equipment Corporation.                          */
/* Distributed only by permission.                                        */
/**************************************************************************/
/* File: exception.h                                                      */
/* Last modified on Wed Mar 15 16:40:42 PST 1989 by roberts               */
/*                                                                        */
/* Implementation of the C exception handler. Much of the real work is    */
/* done in the exception.h header file.                                   */
/**************************************************************************/

#include <stdio.h>
#include "exception.h"

context_block *exceptionStack = NULL;

exception ANY;

void _RaiseException(exception *e, int v){
    context_block *cb, *xb;
    exception *t;
    int i, found;

    found = 0;
    for (xb = exceptionStack; xb != NULL; xb = xb->link) {
        for (i = 0; i < xb->nx; i++) {
            t = xb->array[i];
            if (t == e || t == &ANY) {
                found = 1;
                break;
            }
        }
        if (found) break;
    }
    if (xb == NULL) exit(EUnhandledException);
    for (cb = exceptionStack; cb != xb && !cb->finally; cb = cb->link);
    exceptionStack = cb;
    cb->id = e;
    cb->value = v;
    longjmp(cb->jmp, ES_Exception);
}

_RaiseException 做两件事：

从 exceptionStack 沿链表向外搜索，找到第一个注册了该异常类型（或 ANY）的上下文节点 xb。
若找到，从当前栈顶向 xb 方向回退，停在第一个含 FINALLY 子句的节点（或 xb 本身），将 exceptionStack 指向该节点，记录异常 id 和 value，然后 longjmp 回该节点的 setjmp 点，返回值设为 ES_Exception。这样中间层的 FINALLY 得以先执行，执行完再重新 RAISE 继续向外搜索。
若整条链都没有匹配，直接 exit(EUnhandledException)。

注意：搜索时只检查 nx 个已注册的 EXCEPT 类型，FINALLY 子句不参与匹配——它只负责在异常穿过时执行清理。

测试程序

text

#include "exception.h"
#include <stdio.h>

exception e = { "假装是个很严重的错误"};
void raiseE(exception *toRaise){
  RAISE(*toRaise,100);
}

void main(){
  int i = 0;
  TRY
    TRY
      ++i;
	  if(a == NULL)
		raiseE(&e);
      --i;
    FINALLY
      printf("FINAL\n");
    ENDTRY
  EXCEPT(e)
    printf("捕获到异常e：%s；异常码：%d\n",e.name,exception_value);
  ENDTRY
    printf("i = %d\n",i);
    system("pause");
}

这段测试演示了嵌套 TRY 和异常传播：

内层 TRY 中 ++i 执行后，若条件触发 raiseE(&e)，则 --i 被跳过。
内层 FINALLY 打印 "FINAL"，然后异常继续向外传播。
外层 EXCEPT(e) 捕获异常，打印异常名称和值。
最终 i 的值为 1（只执行了 ++i，未执行 --i）。

执行流程小结

以测试程序为例，调用栈上的事件顺序：

外层 TRY 展开，压入上下文 A，setjmp 保存栈帧。
内层 TRY 展开，压入上下文 B，setjmp 保存栈帧。
内层正体执行 ++i，随后 RAISE 被调用。
_RaiseException 从 B 开始搜索，B 没有 EXCEPT 子句（nx == 0），继续到 A，A 注册了 e，匹配成功（xb = A）。回退时 B 含 FINALLY，停在 B。
longjmp 回 B 的 setjmp 点，_es = ES_Exception。
内层 FINALLY 执行（打印 "FINAL"），exceptionStack 回退到 A，然后重新 RAISE。
第二次 _RaiseException 从 A 开始搜索，A 注册了 e，匹配成功且无中间 FINALLY，longjmp 回 A 的 setjmp 点。
外层 EXCEPT(e) 匹配，打印异常信息，exceptionStack 恢复为 NULL，break 退出。
程序继续执行 printf("i = %d\n", i)，输出 1。

限制与注意事项

资源泄漏：longjmp 直接跳转，不会执行 TRY 块中已分配但未释放的资源（malloc、文件句柄等）。必须在 FINALLY 中手动清理，否则泄漏。
非线程安全：exceptionStack 是全局变量，多线程环境下会互相覆盖。若需并发使用，必须加锁或改为线程局部存储。
平台依赖：setjmp/longjmp 的行为在 POSIX 和 Windows 上基本一致，但部分编译器（如 MSVC）对 longjmp 后局部变量的可见性有额外限制。测试中的 system("pause") 仅适用于 Windows。
未声明变量：测试代码中 if(a == NULL) 的 a 未声明，实际编译会报错。原文可能是示意写法，使用时需替换为真实指针变量。
异常数量上限：每个作用域最多注册 MaxExceptionsPerScope（10）个 EXCEPT 子句，超出直接 exit，没有优雅降级。
无 RAII 等价物：C 没有析构函数，FINALLY 是唯一清理点。如果忘记写 FINALLY，异常路径上的资源无法自动回收。
代码年代：源码基于 1989 年的 C 标准，main 未声明返回类型（void main()），部分写法在现代编译器下会产生警告。移植到 C99/C11 项目时建议改为 int main(void) 并加上必要的类型限定。

适用场景

这套机制适合：

在纯 C 项目中需要跨多层调用传播错误，又不想逐层检查返回值的场景。
学习 setjmp/longjmp 非局部跳转原理的教学示例。

不适合：

需要与 C++ 异常共存的项目（longjmp 会跳过 C++ 栈展开，导致析构函数不执行）。
高并发服务（全局状态无锁保护）。
对异常路径资源管理要求严格的场景（没有自动清理保证）。

小结

这套实现用约 100 行宏和 30 行 C 代码，在 C 语言中模拟出了 try-except-finally 的基本语义。核心技巧是 setjmp 保存跳转锚点、longjmp 实现非局部跳转、全局链表维护嵌套上下文。理解它有助于把握 C 中错误处理的底层机制，但实际工程中需特别注意资源清理、线程安全和平台差异。