C语言实现异常处理(转)

起因：在c语言工程代码当中，常常要处理各种关于异常的处理，每次当程序比较复杂的时候，就必须用好几个if来嵌套使用，比如

if (xxx)
{
if(xxx)
{
}
else
{
return ERR_NO;
}
}

这样的代码显得非常混乱，也不容易管理，我一直在寻找能跟c++异常机制类似的功能，如果有这样的功能，那么c语言的异常处理不是也很容易打理了么？

由于c的工程当中一般错误都有专有的错误列表，所以在这边，在我们的机制里我只添加了关于错误Id的异常捕捉处理。

思路：

首先，我使用了#define来将c当中没有的关键词替代，比如try,catch,throw，先想到的是用return,break之类的c语言当中先有的关键词来模拟，这就有了我的第一个版本：

#ifndef EXCEPTION_H
#define EXCEPTION_H
// 一个不成熟的exception机制
typedef unsigned int    ERR_TYPE;

#define NO_ERR 0
static ERR_TYPE err; //try-catch-throw错误处理机制

#define try do
#define catch(N) while(0);if(N>=NO_ERR)
#define throw(N) err=N;break;
#define throwAgain(N) err=N;return;

#endif

调用实例代码：

void f(void)
{
try
{
throw(6);
}
catch(err)
{
throwAgain(err);
}
}

int main()
{
try
{
f();
}
catch(err)
{
printf("%d", err);
}
}

这个设计的程序有一个很大的问题，那就是它只能在同级的函数下使用try。

这是什么意思呢？如果我需要这样使用：

Int main()
{
Try
{
f();
}
catch(err)
{
printf("%d", err);
}
}
Void f()
{
G();
// some codes follows..
}
Void g()
{
Throw(3);
}

在g（）throw出异常3的时候，main函数没有办法直接捕捉，而是必须在f()函数下面继续执行后面的语句。就是这套设计的机制多个嵌套的函数是没有办法实施的。

那么还有什么办法可以解决这个问题呢？Goto可以吗？不可以，goto也只能在同级的函数下使用。goto是本地的：它只能跳到所在函数内部的标号上，而不能将控制权转移到所在程序的任意地点 。

最后找到一个方法：

#include <setjmp.h>

int setjmp(jmp_buf env）
Returns: 0 if called directly, nonzero if returning from a call to longjmp.
void longjmp(jmp_buf env, int val);

setjmp 和longjmp这2个函数可以在不同的函数进行跳转，只要设置他们的上下文，在用longjmp跳转到这设置好的上下文当中就可以了！！

关于这里的setjmp和longjmp, 在main函数中第一次设置好setjmp后, 其返回值为0; 在longjmp跳转到setjmp后, setjmp的返回值则为longjmp的第二个参数的值, 即不再为0

这2个函数的使用方法：

#include<stdio.h>
#include<setjmp.h>
jmp_buf ebuf;
void f2(void);
int main(void)
{
int i;
printf("1");
i=setjmp(ebuf);
if(i==0)
{
f2();
printf("This will not be printed.");
}
printf("%d",i);
return 0;
}
void f2(void)
{
printf("2");
longjmp(ebuf,3);
}

首先，在函数a里面setjmp，将当前函数的env都存储起来，然后在函数b里面调用longjmp，这样就会直接跳转到函数a的setjmp这个地方，longjmp的第二个值作用是在第二次返回a函数的时候setjmp会返回longjmp的第二个参数。

有了这个方法，我们的程序就好设计多了，由于设计多个函数的调用，所以设计的时候使用了链表来处理保存每个函数的env。

全部实现代码如下：

#ifndef LIST_H
#define LIST_H
typedef struct list_head_tag
{
struct list_head_tag *prev;
struct list_head_tag *next;
}list_head;

#define list_for_each(pos, head) \
for ( pos = (head)->next; \
pos != (head); \
pos = pos->next)

#define list_for_each_safe(pos,pos_next,head) \
for ( pos = (head)->next, pos_next = pos->next; \
pos != (head); \
pos = pos_next, pos_next = pos->next)

#define list_empty(head) (head->next == head)

#define list_entry(ptr, type, member) ((type*)ptr)

#define init_list_head(ptr) \
do{\
(ptr)->prev = ptr; \
(ptr)->next = ptr; \
}while(0)

extern void list_add_before(list_head *node, list_head *pos);

extern void list_add_after(list_head *node, list_head *pos);

extern void list_del(list_head *node);
#endif

#include "list.h"
void list_add_before(list_head *node, list_head *pos)
{
node->prev = pos->prev;
node->next = pos;
pos->prev->next = node;
pos->prev = node;
}
void list_add_after(list_head *node, list_head *pos)
{
node->prev = pos;
node->next = pos->next;
pos->next->prev = node;
pos->next = node;
}
void list_del(list_head *node)
{
node->prev->next = node->next;
node->next->prev = node->prev;
}

#ifndef EXC_H
#define EXC_H
char err = -1;
static char isJumpListInit = 0;
//jmp_buf jump_buffer;
typedef struct JumpBufListTag
{
struct list_head_tag list;
jmp_buf jump_buffer;
}JumpBufList, *JumpBufListPtr;
JumpBufList jumplist = {NULL, NULL};
JumpBufListPtr head = &jumplist;
JumpBufListPtr cur = &jumplist;
int SetCurJump(void)
{
JumpBufListPtr newPtr = (JumpBufList*)calloc(sizeof(JumpBufList));
if (!isJumpListInit)
{
init_list_head(&head->list);
isJumpListInit = 1;
}
list_add_after(&newPtr->list, &head->list);
cur = newPtr;
return 0;
}
void JumpCurLong(void)
{
longjmp(cur->jump_buffer, 1);
}
void DestoryCurJumpEnv( void )
{
list_del(&cur->list);
free(cur);
cur = head->list.next;
}
#define try SetCurJump();if(setjmp(cur->jump_buffer) == 0)
#define catch(N) DestoryCurJumpEnv();if(N>=0)
#define throw(N) err=N;JumpCurLong();
#endif

这边，List.h和list.c摘抄自linux内核代码。

使用demo代码：

void h()
{
throw(7);
}
void e()
{
h();
}
void g(void)
{
try
{
e();
printf("g()3");
}
catch(err)
{
throw(err);
}
}
int main()
{

try
{
g();

}
catch(err)
{
printf("%d", err);
}
return 0;
}

这样，就可以实现一个简易版本的用c语言模拟c++的错误处理异常的机制了。