C语言中setjmp与longjmp学习笔记

C语言中setjmp与longjmp学习笔记

一、基础介绍

    头文件：#include<setjmp.h>

    原型：  int setjmp(jmp_buf envbuf)

    宏函数setjmp()在缓冲区envbuf中保存系统堆栈里的内容，供longjmp()以后使用。首次调用setjmp()宏时，返回值为0，然而longjmp()把一个变原传递给setjmp(),该值（恒不为0）就是调用longjmp()后出现的setjmp()的值。

void longjmp(jmp_buf envbuf,int status);

    函数longjmp()使程序在最近一次调用setjmp()处重新执行。

    setjmp()和longjmp()提供了一种在函数间调转的手段。函数longjmp()通过把堆栈复位成envbuf中描述的状态进行操作，envbuf的设置是由预先调用setjmp()生成的。这样使程序的执行在setjmp()调用后的下一个语句从新开始，使计算机认为从未离开调用setjmp()的函数。从效果上看，longjmp()函数似乎"绕"过了时间和空间（内存）回到程序的原点，不必执行正常的函数返回过程。

    缓冲区envbuf具有<setjmp.h>中定义的buf_jmp类型，它必须调用longjmp()前通过调用setjmp()来设置好，而值status变成setjmp()的返回值，由此确定长调转的来处。不允许的唯一值是0，0是程序直接调用函数setjmp()时由该函数返回的，不是间接通过执行函数longjmp()返回的。longjmp()函数最常用于在一个错误发生时，从一组深层嵌套的实用程序中返回。

    简单实例:

#include<stdio.h>

#include <setjmp.h>

jmp_buf ebuf;

void f2(void);

int main(void){

    int i;

    printf("1 ");

    i = setjmp(ebuf);

    printf("i=%d\n",i);//注意它不会输出

    if (i == 0){

        printf("22 ");

        longjmp(ebuf, 3);//返回setjmp执行点

        printf("This will not be printed.");//注意它不会输出

    }

    printf("%d，", i);

    return 0;

}

 

程序输出: 1 2 3

     在linux内核中，异常大多使用goto来处理。实际上goto语句是面向过程与面向结构化程序语言中，进行异常处理编程的最原始的支持形式。后来为了更好地、更方便地支持异常处理编程机制，使得程序员在C语言开发的程序中，能写出更高效、更友善的带有异常处理机制的代码模块来。于是，C语言中出现了一种更优雅的异常处理机制，那就是setjmp()函数与longjmp()函数。

    实际上，这种异常处理的机制不是C语言中自身的一部分，而是在C标准库中实现的两个非常有技巧的库函数，也许大多数C程序员朋友们对它都很熟悉，而且，通过使用setjmp()函数与longjmp()函数组合后，而提供的对程序的异常处理机制，以被广泛运用到许多C语言开发的库系统中，如jpg解析库，加密解密库等等。

    也许C语言中的这种异常处理机制，较goto语句相比较，它才是真正意义上的、概念上比较彻底的，一种异常处理机制。作风一向比较严谨、喜欢刨根问底的主人公阿愚当然不会放弃对这种异常处理机制进行全面而深入的研究。下面一起来看看。

 

二、setjmp的使用分析

    前面刚说了，setjmp是C标准库中提供的一个函数，它的作用是保存程序当前运行的一些状态。

    它的函数原型如下：int setjmp( jmp_buf env );

　 这是MSDN中对它的评论，如下：

　  setjmp函数用于保存程序的运行时的堆栈环境，接下来的其它地方，你可以通过调用longjmp函数来恢复先前被保存的程序堆栈环境。当setjmp和longjmp组合一起使用时，它们能提供一种在程序中实现"非本地局部跳转"（"non-local goto"）的机制。并且这种机制常常被用于来实现，把程序的控制流传递到错误处理模块之中；或者程序中不采用正常的返回（return）语句，或函数的正常调用等方法，而使程序能被恢复到先前的一个调用例程（也即函数）中。

　　对setjmp函数的调用时，会保存程序当前的堆栈环境到env参数中；接下来调用longjmp时，会根据这个曾经保存的变量来恢复先前的环境，并且当前的程序控制流，会因此而返回到先前调用setjmp时的程序执行点。此时，在接下来的控制流的例程中，所能访问的所有的变量（除寄存器类型的变量以外），包含了longjmp函数调用时，所拥有的变量。而寄存器类型的变量将不可预料。setjmp函数返回的值必须是非零值，如果longjmp传送的value参数值为0，那么实际上被setjmp返回的值是1。

　　setjmp和longjmp并不能很好地支持C++中面向对象的语义。因此在C++程序中，请使用C++提供的异常处理机制。

在使用longjmp时，请遵守以下规则或限制：

　　①不要假象寄存器类型的变量将总会保持不变。在调用longjmp之后，通过setjmp所返回的控制流中，例程中寄存器类型的变量将不会被恢复。

      ②不要使用longjmp函数，来实现把控制流，从一个中断处理例程中传出，除非被捕获的异常是一个浮点数异常。在后一种情况下，如果程序通过调用_fpreset函数，来首先初始化浮点数包后，它是可以通过longjmp来实现从中断处理例程中返回。

      ③在C++程序中，小心对setjmp和longjmp的使用，应为setjmp和longjmp并不能很好地支持C++中面向对象的语义。因此在C++程序中，使用C++提供的异常处理机制将会更加安全。

 

四、深入分析 

      setjmp 是 C 语言解决 exception 的标准方案。

      setjmp/longjmp 这组 api 的名字没有取好，导致了许多误解。名字体现的是其行为：跳转，却没能反映其功能：exception 的抛出和捕获。

      longjmp 从名字上看，叫做长距离跳转。实际上它能做的事情比名字上看起来的要少得多。跳转并非从静止状态的代码段的某个点跳转到另一个位置（类似在汇编层次的 jmp 指令做的那样），而是在运行态中向前跳转。C 语言的运行控制模型，是一个基于栈结构的指令执行序列。表示出来就是 call / return ：调用一个函数，然后用 return 指令从一个函数返回。setjmp/longjmp 实际上是完成的另一种调用返回的模型。setjmp 相当于call ，longjmp 则是 return 。

      重要的区别在于：setjmp 不具备函数调用那样灵活的入口点定义；而 return 不具备 longjmp 那样可以灵活的选择返回点。其次，第一、setjmp 并不负责维护调用栈的数据结构，即，你不必保证运行过程中 setjmp 和longjmp 层次上配对。如果需要这种层次，则需要程序员自己维护一个调用栈。这个调用栈往往是一个 jmp_buf的序列；第二、它也不提供调用参数传递的功能，如果你需要，也得自己来实现。

      以库形式提供的 setjmp/longjmp 和以语言关键字 return 提供的两套平行的运行流控制放在一起，大大拓展了 C 语言的能力。把 setjmp/longjmp 嵌在单个函数中使用，可以模拟 pascal 中嵌套函数定义：即在函数中定义一个局部函数ps. GNUC 扩展了 C 语

言，也在语法上支持这种定义方法。这种用法可以让几个局部函数有访问和共享 upvalue 的能力。

      把 setjmp/longjmp 放在大框架上，则多用来模拟 exception 机制。setjmp 也可以用来模拟 coroutine 。但是会遇到一个难以逾越的难点：正确的 coroutine 实现需要为每个 coroutine 配备一个独立的数据栈，这是setjmp 无法做到的。虽然有一些 C 的 coroutine 库用 setjmp/longjmp 实现。但使用起来都会有一定隐患。多半是在单一栈上预留一块空间，然后给另一个 coroutine 运行时覆盖使用。当数据栈溢出时，程序会发生许多怪异的现象，很难排除这种溢出 bug 。要正确的实现 coroutine ，还需要 setcontext 库 ，这已经不是 C 语言的标准库了。

      在使用 setjmp 时，最常见的一个错误用法就是对 setjmp 做封装，用一个函数去调用它。比如：

int try(breakpoint bp)

{

      return setjmp(bp->jb);

}

void throw(breakpoint bp)

{

      longjmp(bp->jb,1);

}

      setjmp 不应该封装在一个函数中。这样写并不讳引起编译错误。但十有八九会引起运行期错误。错误的起源在于 longjmp 的跳转返回点，必须在运行流经过并有效的位置。而如果对 setjmp 做过一层函数调用的封装后。上例中的 setjmp 设置的返回点经过 try 的调用返回后，已经无效。如果要必要封装的话，应该使用宏。

      setjmp/longjmp 对于大多数 C 程序员来说比较陌生。正是在于它的定义含糊不清，不太容易弄清楚。使用上容易出问题，运用场合也就变的很狭窄，多用于规模较大的库或框架中。和 C++ 语言提供的 execption 机制一样，很少有构架师愿意把它暴露到外面，那需要对二次开发的程序员有足够清晰的头脑，并充分理解其概念才不会用错。这往往是不可能的。另外，setjmp/longjmp 的理念和 C++ 本身的 RAII 相冲突。虽然许多编译器为防止 C++ 程序员错误使用 setjmp 都对其做了一定的改进。让它可以正确工作。但大多数情况下，还是在文档中直接声明不推荐在 C++ 程序中使用这个东西。

 

 

 

 

 

 

 

我们有3个小文件分别为main.c file1.c file2.c，下面列出他们：

int main()

{

    jmp_buf main_stat;

    if(setjmp(error_stat)!=0)

        {

            printf(" error in main \n");

            return -1;

        }

    file1();

    return 0;

}

int file1()

{

    jmp_buf file1_stat;

    memcpy(&file1_stat,&error_stat,sizeof(file1_stat));

    if(setjmp(error_stat)!=0)

        {

            printf(" error in file1 \n");

            memcpy(&error_stat,&file1_stat,sizeof(file1_stat));

            longjmp(error_stat,1);

        }

    file2();

}

int file2()

{

    jmp_buf file2_stat;

    memcpy(&file2_stat,&error_stat,sizeof(file2_stat));

    if(setjmp(error_stat)!=0)

        {

            printf(" error in file2 \n");

            memcpy(&error_stat,&file2_stat,sizeof(file2_stat));

            longjmp(error_stat,1);

        }

    printf(" start error \n");

    longjmp(error_stat,1);//从这里开始返回

}

对他们进行编译，运行，输出结果为：

 start error 

 error in file2 

 error in file1 

 error in main 

这只是一个很简单的例子，而且是按照层次传递的，不按照层次传递的代码与之类似。

通过使用setjmp/longjmp，可以在C语言中实现模仿C++层次传递的异常处理机制。这种实现方式效率比较高，在大规模工程项目中能够很好的实现异常处理，减轻程序的复杂度。

 

 

 

 

 

 

 

 

 c语言中的异常处理机制setjmp和longjmp

#include <setjmp.h>

#include <stdlib.h>

#include <stdio.h>

#include <assert.h>

 

int Allocation_handled = 0;

jmp_buf Allocate_Failed;

 

void *allocate(unsigned n)

{

void * p = (void *)malloc(n);

 

if (p)

return p;

 

if (Allocation_handled) /* 如果实例化了异常处理程序的话... */

longjmp(Allocate_Failed, 1); /* 产生异常，并抛出 */

 

assert(0); /* 如果没有实例化异常处理程序，则此断言会报出运行期的错误 */

}

 

 

int main(int argc, char *argv[])

{

char *buf = 0;

int count = 0;

 

 

Allocation_handled = 1; /* 设置实例化异常的标志，设为1表示实例化了异常处理程序 */

if (setjmp(Allocate_Failed)) /* 实例化异常 */

{

fprintf(stderr, "EXCEPT: Couldn't allocate the buffer\n");

exit(EXIT_FAILURE);

}

 

while(1) /* 测试代码：一直分配内存，直到没有内存为止。没有内存时会触发异常 */

{

buf = (char *)allocate(4096000);

printf("Allocate successs, the count is: %d\n", count++);

}

 

Allocation_handled = 0;

    return 0;

}

 

简要讲述一下代码的流程：

1.setjmp用来实例化异常处理程序，在这里我们的异常处理程序就是往stderr输出一个字符串并退出应用程序。

 

2.setjmp会返回2次值（颇有些fork()的味道）。setjmp第一次返回值是在应用代码（这里就是main函数里面）调用setjmp的地方，这时候它实例化了异常处理程序，并返

回0,所以异常处理程序的代码并没有被执行。在allocate中调用longjmp的时候，会引起setjmp第二次值的返回，此时的返回值由

longjmp的第二个参数所决定。文中我们调用longjmp的时候，传给它的第二个参数是1,所以setjmp返回时会执行if中的异常处理程序。

 

 

 

 

 

 

 

 

 

 

 

浅析C语言的非局部跳转：setjmp和longjmp

 

C语言中有一个goto语句，其可以结合标号实现函数内部的任意跳转（通常情况下，很多人都建议不要使用goto语句，因为采用goto语句后，代码维护工作量加大）。另外，C语言标准中还提供一种非局部跳转"no-local goto"，其通过标准库<setjmp.h>中的两个标准函数setjmp和longjmp来实现。

C标准库<setjmp.h>

 

下面是K＆R的《C程序设计语言（第2版 . 新版）》第232页给出的关于标准库<setjmp.h>的说明。

8 setjmp.h 

 

头文件<setjmp.h>中的说明提供了一种避免通常的函数调用和返回顺序的途径，特别的，它允许立即从一个多层嵌套的函数调用中返回。 

 

setjmp()宏把当前状态信息保存到env中，供以后longjmp()恢复状态信息时使用。如果是直接调用setjmp()，那么返回值为0；如果是由于调用longjmp()而调用setjmp()，那么返回值非0。setjmp()只能在某些特定情况下调用，如在if语句、 switch语句及循环语句的条件测试部分以及一些简单的关系表达式中。 

 

 

8.2 longjmp 

 

#include <setjmp.h> 

 

void longjmp(jmp_buf env, int val); 

 

 

longjmp()用于恢复由最近一次调用setjmp()时保存到env的状态信息。当它执行完时，程序就象setjmp()刚刚执行完并返回非0值val那样继续执行。包含setjmp()宏调用的函数一定不能已经终止。所有可访问的对象的值都与调用longjmp()时相同，唯一的例外是，那些调用setjmp()宏的函数中的非volatile自动变量如果在调用setjmp()后有了改变，那么就变成未定义的。 

 

jmp_buf是setjmp.h中定义的一个结构类型，其用于保存系统状态信息。宏函数setjmp会将其所在的程序点的系统状态信息保存到某个jmp_buf的结构变量env中，而调用函数longjmp会将宏函数setjmp保存在变量env中的系统状态信息进行恢复，于是系统就会跳转到setjmp()宏调用所在的程序点继续进行。这样setjmp/longjmp就实现了非局部跳转的功能。

一个简单的例子：

 

下面我们来看一个简单的例子。

 1 #include <stdio.h> 

 

 2 #include <setjmp.h> 

 

 3 

 

 4 jmp_buf jump_buffer; 

 

 5 

 

 6 void func(void) 

 

 7 { 

 

 8 printf("Before calling longjmp\n"); 

 

 9 longjmp(jump_buffer, 1); 

 

10 printf("After calling longjmp\n"); 

 

11 } 

 

12 void func1(void) 

 

13 { 

 

14 printf("Before calling func\n"); 

 

15 func(); 

 

16 printf("After calling func\n"); 

 

17 } 

 

18 int main() 

 

19 { 

 

20 if (setjmp(jump_buffer) == 0){ 

 

21 printf("first calling set_jmp\n"); 

 

22 func1(); 

 

23 }else { 

 

24 printf("second calling set_jmp\n"); 

 

25 } 

 

26 return 0; 

 

27 } 

 

代码的运行结果如下

lienhua34@lienhua34-laptop:~/program/test$ ./test 

 

first calling set_jmp 

 

Before calling func 

 

Before calling longjmp 

 

second calling set_jmp  

 

通过上面这个简单例子的运行结果可以看出。main函数运行的setjmp()宏调用，将当前程序点的系统状态信息保存到全局变量jump_buffer中，然后返回结果0。于是，代码打印出字符串"first calling set_jmp"，然后调用函数func1()。在函数func1中，先打印字符串"Before calling func"，然后去调用函数func()。现在程序控制流转到func函数中，函数func先打印字符串"Before calling longjmp"，然后调用函数longjmp。这时候关键点到了！！！longjmp函数将main函数中setjmp()宏调用设置在全局变量jump_buffer中的系统状态信息恢复到系统的相应寄存器中，导致程序的控制流跳转到了main函数中setjmp()宏调用所在的程序点，此时相当于第二次进行setjmp()宏调用，并且此时的setjmp()宏调用的返回不再是0，而是传递给函数调用longjmp()的第二个参数1。于是程序控制流转到main函数中if语句的else部分执行，打印字符串"second calling set_jmp"。最后，执行main函数中的语句"reture 0;"返回，程序运行结束退出。

   

从上面的运行过程，我们可以看出在longjmp()函数调用处的程序点嵌套在三层函数调用中：main, func1和func，但是longjmp()函数调用导致程序控制流跳过函数调用func和func1，直接回到main函数中setjmp()宏调用所在的程序点，然后执行main函数中后续的语句，从而忽略了函数func1和func中后续的语句部分。这就是非局部跳转。

 

 

 

 

 

#include<iostream>

#include<csetjmp>

using namespace std;

class Rainbow{

public:

Rainbow(){cout << "Rainbow()" << endl;

~Rainbow(){cout << "~Rainbow()" << endl;

};

jmp_buf kansas;

void oz()

{

Rainbow rb;

for(int i=0;i<3;i++)

cout << "there's no place like home" << endl;

longjmp(kansas,47);

}

int main()

{

if(setjmp(kansas)==0)

{

cout << "tornado.witch.munchkins..." << endl;

oz();

}

else

{

cout << "Auntie em!"

<< "I had the strangest dream..."

<< endl;

}

}

//例子摘自C++编程思想第二卷实用技术编程

 

 

 

 

 

 

 

 

C异常处理机制：setjmp和longjmp

    注:本文主要来自网络,本人简单修改,并蓝色注明

    setjmp()和longjum()是通过操纵过程活动记录实现的。它是C语言所独有的。它们赋予了C语言有限的转移能力。这个两个函数协同工作，如下：

    *setjmp(jmp_buf env)必须首先被调用。它表示"使用变量env记录现在的位置（当前的堆栈信息，也可以理解成，跳转点吧。据说还会保存一些变量信息，但我实验中没有发现）。第一次调用时，返回0；之后，通过longjmp跳转到时，返回longjmp传入的第二个参数。此外，本函数只能在一个地方使用，下面的longjmp可以在任意个像直接跳到setjmp的地方调用。

    *longjmp(jmp_buf env,int error)可以接着被调用。它表示"回到env所记录的位置，让它看上去像是从原来的setjmp()函数返回一样。但是函数返回error，使代码知道它实际上是通过longjmp()返回的。

注意：setjmp和longjmp是一对多的关系，并且只有longjmp的第一个参数和setjmp的第一个参数一样的话，才能跳转到那个setjmp所设置的跳转点哦，因为那个参数保存了第一次调用setjmp，也就是设置跳转点是的堆栈信息。

    setjmp保存了一份程序的计数器和当前的栈顶指针。如果喜欢也可以保存一些初始值（据说是可以保存一些，但。。。）。longjmp恢复这些值，有效的转移控制并把状态重置回保存状态的时候。这被称做"展开堆栈(unwinding stack)"，因为你从堆栈中展开过程活动记录，直到取得保存在其中的值。尽管longjmp会导致转移，但它和goto又有不同，区别如下：

    *goto语句不能跳出C语言当前的函数（这也是"longjmp"取名的由来，它可以跳的很远，甚至可以跳到其他文件的函数中）。

    *用longjmp只能跳回到曾经到过的地方。在setjmp的地方仍留有一个过程活动记录。从这个角度讲，longjmp更像是"回到哪儿去"而不是"往哪里去（go to)"。longjmp接受一个额外的整型参数并返回它的值，这可以知道是由longjmp转移到这里的还是从上条语句执行后自然而然来的这里的。

 

    下面的代码显示了setjmp()和longjmp()一例。

     #include <stdio.h>

     #include <setjmp.h>

     jmp_buf buf;

   

     banana() {

         printf("%s","in banana() \n");

         longjmp(buf,1);

         printf("%s","you will never see this \n");

     }

      int main() {

         if(setjmp(buf)) { //第一次调用时，返回0；之后，跳到这的话，返回longjmp

                        //所指定的值，但不能是0了哦。。。

             printf("%s","back in main\n");

         }

         else {

             printf("%s","first time throught\n");

             banana();

         }

     }

    输出结果如下：

    first time throught

    in banana()

    back in main

    需要注意的地方是：保证局部变量在longjmp过程中一直保持它的值的唯一可靠方法是把它声明为volatile(这使用于那些值在setjmp执行和longjmp返回之间会改变的变量),

    setjmp/longjmp最大的用途是错误恢复。只要还没有从函数中返回，一旦发现一个不可恢复的错误，可以把控制转移到主输入循环，并从那里重新开始。有些人使用setjmp/longjmp从一串无数的函数调用中立即返回。还有些人用它们防范潜在的危险代码。还有哦，java智能卡中本地方法异常处理也是借助他们哦。

    setjmp/longjmp在C++中演变为更普通的异常处理机制"catch"和"throw"。

 

 

 

 

 

 

 

 

 

setjmp与longjmp相结合，实现程序的非本地的跳转

　　呵呵！这就是goto语句所不能实现的。也正因为如此，所以才说在C语言中，setjmp与longjmp相结合的方式，它提供了真正意义上的异常处理机制。其实上一篇文章中的那个例程，已经演示了longjmp函数的非本地跳转的场景。这里为了更清晰演示本地跳转与非本地跳转，这两者之间的区别，我们在上面刚才的那个例程基础上，进行很小的一点改动，代码如下：

void Func1()

{

// 其它代码的执行

// 判断程序远行中，是否出现错误，如果有错误，则跳转！

if(1) longjmp(mark, 1);

}

void Func2()

{

// 其它代码的执行

// 判断程序远行中，是否出现错误，如果有错误，则跳转！

if(2) longjmp(mark, 2);

}

void Func3()

{

// 其它代码的执行

// 判断程序远行中，是否出现错误，如果有错误，则跳转！

if(-1) longjmp(mark, -1);

}

void main( void )

{

int jmpret;

jmpret = setjmp( mark );

if( jmpret == 0 )

{

// 其它代码的执行

// 下面的这些函数执行过程中，有可能出现异常

Func1();

Func2();

Func3();

// 其它代码的执行

}

else

{

// 错误处理模块

switch (jmpret)

{

case 1:

printf( "Error 1\n");

break;

case 2:

printf( "Error 2\n");

break;

case 3:

printf( "Error 3\n");

break;

default :

printf( "Unknown Error");

break;

}

exit(0);

}

return;

}

 

　　回顾一下，这与C++中提供的异常处理模型是不是很相近。异常的传递是可以跨越一个或多个函数。这的确为C程序员提供了一种较完善的异常处理编程的机制或手段。

setjmp和longjmp使用时，需要特别注意的事情

　　1、setjmp与longjmp结合使用时，它们必须有严格的先后执行顺序，也即先调用setjmp函数，之后再调用longjmp函数，以恢复到先前被保存的"程序执行点"。否则，如果在setjmp调用之前，执行longjmp函数，将导致程序的执行流变的不可预测，很容易导致程序崩溃而退出。请看示例程序，代码如下：

class Test

{

public:

Test() {printf("构造对象\n");}

~Test() {printf("析构对象\n");}

}obj; 

//注意，上面声明了一个全局变量obj

void main( void )

{

int jmpret;

// 注意，这里将会导致程序崩溃，无条件退出

Func1();

while(1);

jmpret = setjmp( mark );

if( jmpret == 0 )

{

// 其它代码的执行

// 下面的这些函数执行过程中，有可能出现异常

Func1();

Func2();

Func3();

// 其它代码的执行

}

else

{

// 错误处理模块

switch (jmpret)

{

case 1:

printf( "Error 1\n");

break;

case 2:

printf( "Error 2\n");

break;

case 3:

printf( "Error 3\n");

break;

default :

printf( "Unknown Error");

break;

}

exit(0);

}

return;

}

　　上面的程序运行结果，如下：

　　构造对象

　　Press any key to continue

　　的确，上面程序崩溃了，由于在Func1()函数内，调用了longjmp，但此时程序还没有调用setjmp来保存一个程序执行点。因此，程序的执行流变的不可预测。这样导致的程序后果是非常严重的，例如说，上面的程序中，有一个对象被构造了，但程序崩溃退出时，它的析构函数并没有被系统来调用，得以清除一些必要的资源。所以这样的程序是非常危险的。（另外请注意，上面的程序是一个C++程序，所以大家演示并测试这个例程时，把源文件的扩展名改为xxx.cpp）。

　　2、除了要求先调用setjmp函数，之后再调用longjmp函数（也即longjmp必须有对应的setjmp函数）之外。另外，还有一个很重要的规则，那就是longjmp的调用是有一定域范围要求的。这未免太抽象了，还是先看一个示例，如下：

 

int Sub_Func()

{

int jmpret, be_modify;

be_modify = 0;

jmpret = setjmp( mark );

if( jmpret == 0 )

{

// 其它代码的执行

}

else

{

// 错误处理模块

switch (jmpret)

{

case 1:

printf( "Error 1\n");

break;

case 2:

printf( "Error 2\n");

break;

case 3:

printf( "Error 3\n");

break;

default :

printf( "Unknown Error");

break;

}

//注意这一语句，程序有条件地退出

if (be_modify==0) exit(0);

}

return jmpret;

}

void main( void )

{

Sub_Func();

// 注意，虽然longjmp的调用是在setjmp之后，但是它超出了setjmp的作用范围。

longjmp(mark, 1);

}

　　如果你运行或调试（单步跟踪）一下上面程序，发现它真是挺神奇的，居然longjmp执行时，程序还能够返回到setjmp的执行点，程序正常退出。但是这就说明了上面的这个例程的没有问题吗？我们对这个程序小改一下，如下：

int Sub_Func()

{

// 注意，这里改动了一点

int be_modify, jmpret;

be_modify = 0;

jmpret = setjmp( mark );

if( jmpret == 0 )

{

// 其它代码的执行

}

else

{

// 错误处理模块

switch (jmpret)

{

case 1:

printf( "Error 1\n");

break;

case 2:

printf( "Error 2\n");

break;

case 3:

printf( "Error 3\n");

break;

default :

printf( "Unknown Error");

break;

}

//注意这一语句，程序有条件地退出

if (be_modify==0) exit(0);

}

return jmpret;

}

void main( void )

{

Sub_Func();

// 注意，虽然longjmp的调用是在setjmp之后，但是它超出了setjmp的作用范围。

longjmp(mark, 1);

}

 

　　运行或调试（单步跟踪）上面的程序，发现它崩溃了，为什么？这就是因为，"在调用setjmp的函数返回之前，调用longjmp，否则结果不可预料"（这在上一篇文章中已经提到过，MSDN中做了特别的说明）。为什么这样做会导致不可预料？其实仔细想想，原因也很简单，那就是因为，当setjmp函数调用时，它保存的程序执行点环境，只应该在当前的函数作用域以内（或以后）才会有效。如果函数返回到了上层（或更上层）的函数环境中，那么setjmp保存的程序的环境也将会无效，因为堆栈中的数据此时将可能发生覆盖，所以当然会导致不可预料的执行后果。

 

　　3、不要假象寄存器类型的变量将总会保持不变。在调用longjmp之后，通过setjmp所返回的控制流中，例程中寄存器类型的变量将不会被恢复。（MSDN中做了特别的说明，上一篇文章中，这也已经提到过）。寄存器类型的变量，是指为了提高程序的运行效率，变量不被保存在内存中，而是直接被保存在寄存器中。寄存器类型的变量一般都是临时变量，在C语言中，通过register定义，或直接嵌入汇编代码的程序。这种类型的变量一般很少采用，所以在使用setjmp和longjmp时，基本上不用考虑到这一点。

 

　　4、MSDN中还做了特别的说明，"在C++程序中，小心对setjmp和longjmp的使用，因为setjmp和longjmp并不能很好地支持C++中面向对象的语义。因此在C++程序中，使用C++提供的异常处理机制将会更加安全。"虽然说C++能非常好的兼容C，但是这并非是100%的完全兼容。例如，这里就是一个很好的例子，在C++程序中，它不能很好地与setjmp和longjmp和平共处。在后面的一些文章中，有关专门讨论C++如何兼容支持C语言中的异常处理机制时，会做详细深入的研究，这里暂且跳过。

 

 

 

 

 

 

 

 

 

 

C语言中的异常处理

一 前言：

异常处理，对于做面向对象开发的开发者来说是再熟悉不过了，例如在C#中有

try

{

     ...

}

catch( Exception e){...}

finally{

.....

}

在C++中，我们常常会使用

try{}

...

catch(){}

块来进行异常处理。

说了那么多，那么到底什么是异常处理呢？

异常处理（又称为错误处理）功能提供了处理程序运行时出现的任何意外或异常情况的方法。

异常处理一般有两种模型，一种是"终止模型"，一种是"恢复模型"

"终止模型":在这种模型中,将假设错误非常关键,将以致于程序无法返回到异常发生的地方继续执行.一旦异常被抛出,就表明错误已无法挽回,也不能回来继续执行.

"恢复模型":异常处理程序的工作是修正错误,然后重新尝试调动出问题的方法,并认为的二次能成功. 对于恢复模型,通常希望异常被处理之后能继续执行程序.在这种情况下,抛出异常更像是对方法的调用--可以在Java里用这种方法进行配置,以得到类似恢复的行为.(也就是说,不是抛出异常,而是调用方法修正错误.)或者,把try块放在while循环里,这样就可以不断的进入try块,直到得到满意的结果. 

二 面向对象中的异常处理

大致了解了什么是异常处理后，由于异常处理在面向对象语言中使用的比较普遍，我们就先以C++为例，做一个关于异常处理的简单例子：

问题：求两个数相除的结果。

这里，隐藏这一个错误，那就是当除数为0时，会出现，所以，我们得使用异常处理来捕捉这个异常，并抛出异常信息。

具体看代码：

   

 1 #include <iostream>

 2 #include <exception>

 3 using namespace std;

 4 class DivideError:public exception

 5 {

 6  public:

 7           DivideError::DivideError():exception(){} 

 8          const char* what(){

 9             return "试图去除一个值为0的数字";

10         }

11 

12 };

13 double quotion(int numerator,int denominator)

14 {

15     if(0==denominator)          //当除数为0时，抛出异常 

16     throw DivideError();

17     return static_cast<double>(numerator)/denominator;    

18 }

19 int main()

20 {

21     int number1;             //第一个数字

22     int number2;             //第二个数字

23     double result;

24     cout<<"请输入两个数字：" ;

25     while(cin>>number1>>number2){

26         try{

27             result=quotion(number1,number2);

28             cout<<"结果是 :"<<result<<endl;

29             

30         }     //end try

31         catch(DivideError &divException){

32             cout<<"产生异常:"

33                 <<divException.what()<<endl;

34         }

35     }

36     

37 }

38 

   

   

在这个例子中，我们使用了<expection>头文件中的exception类，并使DivideError类继承了它，同时重载了虚方法what()，以给出特定的异常信息。

而C#中的异常处理类则封装的更有全面，里面封装了常用的异常处理信息，这里就不多说了。

   

   

 

 

 

三 C语言中的异常处理

 在C语言中异常处理一般有这么几种方式：

1.使用标准C库提供了abort()和exit()两个函数，它们可以强行终止程序的运行，其声明处于<stdlib.h>头文件中。

2.使用assert(断言)宏调用，位于头文件<assert.h>中，当程序出错时，就会引发一个abort（）。

3.使用errno全局变量，由C运行时库函数提供，位于头文件<errno.h>中。

4.使用goto语句，当出错时跳转。

5.使用setjmp,longjmp进行异常处理。

接下来，我们就依次对这几种方式来看看到底是怎么做的：

我们仍旧以前面处理除数为0的异常为例子。

1.使用exit()函数进行异常终止：

 1 #include <stdio.h>

 2 #include <stdlib.h>

 3 double diva(double num1,double num2)         //两数相除函数 

 4 {

 5     double re;

 6     re=num1/num2;

 7     return re;

 8 }

 9 int main()

10 {

11    double a,b,result;

12  printf("请输入第一个数字：");

13   scanf("%lf",&a);

14   printf("请输入第二个数字：");

15   scanf("%lf",&b);

16   if(0==b)                                //如果除数为0终止程序 

17   exit(EXIT_FAILURE);

18 result=diva(a,b);

19    printf("相除的结果是: %.2lf\n",result);    

20 return 0;

21 }

其中exit的定义如下：

_CRTIMP void __cdecl __MINGW_NOTHROW exit (int) __MINGW_ATTRIB_NORETURN;

exit的函数原型：void exit(int)由此，我们也可以知道EXIT_FAILURE宏应该是一个整数，exit（）函数的传递参数是两个宏，一个是刚才看到的EXIT_FAILURE，还有一个是EXIT_SUCCESS从字面就可以看出一个是出错后强制终止程序，而一个是程序正常结束。他们的定义是：

#define EXIT_SUCCESS 0

#define EXIT_FAILURE 1

到此，当出现异常的时候，程序是终止了，但是我们并没有捕获到异常信息，要捕获异常信息，我们可以使用注册终止函数atexit(),它的原型是这样的：int atexit(atexit_t func);

具体看如下程序：

   

 1 #include <stdio.h>

 2 #include <stdlib.h>

 3 void Exception(void)                           //注册终止函数，通过挂接到此函数，捕获异常信息 

 4 {

 5     printf("试图去除以一个为0的数字，出现异常！\n");

 6 }

 7 int main()

 8 { 

 9    double a,b,result;

10   printf("请输入第一个数字：");

11   scanf("%lf",&a);

12   printf("请输入第二个数字：");

13   scanf("%lf",&b);

14   if(0==b)                    //如果除数为0终止程序 ,并挂接到模拟异常捕获的注册函数

15   {

16       

17   atexit(Exception);                          

18   exit(EXIT_FAILURE);

19   } 

20    result=diva(a,b);

21    printf("相除的结果是: %.2lf\n",result);    

22 return 0;

23 }

这里需要注意的是，atexit（）函数总是被执行的，就算没有exit（）函数，当程序结束时也会被执行。并且，可以挂接多个注册函数，按照堆栈结构进行执行。abort（）函数与exit（）函数类似，当出错时，能使得程序正常退出，这里就不多说了。

 

2.使用assert()进行异常处理：

assert()是一个调试程序时经常使用的宏，切记，它不是一个函数，在程序运行时它计算括号内的表达式，如果表达式为FALSE  (0),  程序将报告错误，并终止执行。如果表达式不为0，则继续执行后面的语句。这个宏通常原来判断程序中是否出现了明显非法的数据，如果出现了终止程序以免导致严重后果，同时也便于查找错误。   

另外需要注意的是：assert只有在Debug版本中才有效，如果编译为Release版本则被忽略。

我们就前面的问题，使用assert断言进行异常终止操作：构造可能出现出错的断言表达式：assert（number！=0）这样，当除数为0的时候，表达式就为false，程序报告错误，并终止执行。

代码如下：

#include <stdio.h>

#include <assert.h>

double diva(double num1,double num2)         //两数相除函数 

{

    double re;

    re=num1/num2;

    return re;

}

int main()

{

  printf("请输入第一个数字：");

  scanf("%lf",&a);

  printf("请输入第二个数字：");

  scanf("%lf",&b);

  assert(0!=b);                                //构造断言表达式，捕获预期异常错误

   result=diva(a,b);

   printf("相除的结果是: %.2lf\n",result);    

   return 0;

}

 

3.使用errno全局变量，进行异常处理：

errno全局变量主要在调式中，当系统API函数发生异常的时候，将errno变量赋予一个整数值，根据查看这个值来推测出错的原因。

其中的各个整数值都有一个相应的宏定义，表示不同的异常原因：

#define EPERM        1    /* Operation not permitted */

#define    ENOFILE        2    /* No such file or directory */

#define    ENOENT        2

#define    ESRCH        3    /* No such process */

#define    EINTR        4    /* Interrupted function call */

#define    EIO        5    /* Input/output error */

#define    ENXIO        6    /* No such device or address */

#define    E2BIG        7    /* Arg list too long */

#define    ENOEXEC        8    /* Exec format error */

#define    EBADF        9    /* Bad file descriptor */

#define    ECHILD        10    /* No child processes */

#define    EAGAIN        11    /* Resource temporarily unavailable */

#define    ENOMEM        12    /* Not enough space */

#define    EACCES        13    /* Permission denied */

#define    EFAULT        14    /* Bad address */

/* 15 - Unknown Error */

#define    EBUSY        16    /* strerror reports "Resource device" */

#define    EEXIST        17    /* File exists */

#define    EXDEV        18    /* Improper link (cross-device link?) */

#define    ENODEV        19    /* No such device */

#define    ENOTDIR        20    /* Not a directory */

#define    EISDIR        21    /* Is a directory */

#define    EINVAL        22    /* Invalid argument */

#define    ENFILE        23    /* Too many open files in system */

#define    EMFILE        24    /* Too many open files */

#define    ENOTTY        25    /* Inappropriate I/O control operation */

/* 26 - Unknown Error */

#define    EFBIG        27    /* File too large */

#define    ENOSPC        28    /* No space left on device */

#define    ESPIPE        29    /* Invalid seek (seek on a pipe?) */

#define    EROFS        30    /* Read-only file system */

#define    EMLINK        31    /* Too many links */

#define    EPIPE        32    /* Broken pipe */

#define    EDOM        33    /* Domain error (math functions) */

#define    ERANGE        34    /* Result too large (possibly too small) */

/* 35 - Unknown Error */

#define    EDEADLOCK    36    /* Resource deadlock avoided (non-Cyg) */

#define    EDEADLK        36

/* 37 - Unknown Error */

#define    ENAMETOOLONG    38    /* Filename too long (91 in Cyg?) */

#define    ENOLCK        39    /* No locks available (46 in Cyg?) */

#define    ENOSYS        40    /* Function not implemented (88 in Cyg?) */

#define    ENOTEMPTY    41    /* Directory not empty (90 in Cyg?) */

#define    EILSEQ        42    /* Illegal byte sequence */

   

这里我们就不以前面的除数为0的例子来进行异常处理了，因为我不知道如何定义自己特定错误的errno，如果哪位知道，希望能给出方法。我以一个网上的例子来说明它的使用方法：

#include <errno.h>  

#include <math.h>  

#include <stdio.h>  

int main(void)  

{  

errno = 0;  

if (NULL == fopen("d:\\1.txt", "rb"))  

{  

printf("%d", errno);  

}  

else  

{  

 printf("%d", errno);  

}  

return 0;  }  

 

   

这里试图打开一个d盘的文件，如果文件不存在，这是查看errno的值，结果是2、

当文件存在时，errno的值为初始值0。然后查看值为2的错误信息，在宏定义那边#define    ENOFILE        2    /* No such file or directory */

便知道错误的原因了。

 

4.使用goto语句进行异常处理：

goto语句相信大家都很熟悉，是一个跳转语句，我们还是以除数为0的例子，来构造一个异常处理的例子：

#include <stdio.h>

double diva(double num1,double num2)         //两数相除函数 

{

    double re;

    re=num1/num2;

    return re;

}

int main()

{

  int tag=0;

  double a,b,result;

  if(1==tag)

  {

      Throw:

    printf("除数为0，出现异常\n");

  }

   tag=1;

  printf("请输入第一个数字：");

  scanf("%lf",&a);

  printf("请输入第二个数字：");

  scanf("%lf",&b);

if(b==0)                           //捕获异常（或许这么说并不恰当，暂且这么理解）

  goto Throw;                                //抛出异常 

  result=diva(a,b);

   printf("%d\n",errno);

   printf("相除的结果是: %.2lf\n",result);    

 

return 0;

}

 

5.使用setjmp和longjmp进行异常捕获与处理：

setjmp和longjmp是非局部跳转，类似goto跳转作用，但是goto语句具有局限性，只能在局部进行跳转，当需要跳转到非一个函数内的地方时就需要用到setjmp和longjmp。setjmp函数用于保存程序的运行时的堆栈环境，接下来的其它地方，你可以通过调用longjmp函数来恢复先前被保存的程序堆栈环境。异常处理基本方法：

使用setjmp设置一个跳转点，然后在程序其他地方调用longjmp跳转到该点（抛出异常).

代码如下所示：

#include <stdio.h>

#include <setjmp.h>

jmp_buf j;

void Exception(void)

{

   longjmp(j,1);

}

 double diva(double num1,double num2)         //两数相除函数

 {

    double re;

     re=num1/num2;

    return re;

}

 int main()

{

    double a,b,result;

      

   printf("请输入第一个数字：");

   scanf("%lf",&a);

   printf("请输入第二个数字：");

  if(setjmp(j)==0)

  {

   scanf("%lf",&b);

   if(0==b)

   Exception();

 result=diva(a,b);

    printf("相除的结果是: %.2lf\n",result);

  }

  else

  printf("试图除以一个为0的数字\n");

 return 0;

}

四 总结：

 除了以上几种方法之外，另外还有使用信号量等等方法进行异常处理。当然在实际开发中每个人都有各种调式的技巧，而且这文章并不是说明异常处理一定要这样做，这只是对一般做法的一些总结，也不要乱使用异常处理，如果弄的不好就严重影响了程序的效率和结构，就像设计模式一样，不能胡乱使用。

 

 

 

 

 

 

 

 

上面的说明有点拗口，通俗的解释是：先调用setjmp，用变量envbuf记录当前的位置，然后调用longjmp，返回envbuf所记录的位置，并使setjmp的返回值为val。当时用longjmp时，envbuf的内容被销毁了。其实这里的"位置"一词真正的含义是栈定指针。 

接着让我们看一个小例子吧：

jmp_buf buf;

banana(){ 

    printf("in banana() \n"); 

    longjmp(buf,1);

    printf("you'll never see this,because i longjmp'd");//未执行，因为longjmp会直接跳转到上次的setjmp处。 

}

main() 

{ 

    if(setjmp(buf)) 

        printf("back in main\n"); 

    else{ 

        printf("first time through\n"); 

        banana(); 

    }

}

（代码段引自《C专家编程》：p）

这段代码的打印结果是：

first time through

in banana()

back in main

仔细看一下应该更能体会这对函数的作用了吧。

setjmp/longjmp的最大用处是错误恢复，类似try ...catch...

他们的功能比goto强多了，goto只能在函数体内跳来跳去，而setjmp/longjmp可以在到过的所有位置间。

setjmp() 与 longjmp() 函数都使用了 jmp_buf 结构作为形参，它们的调用关系是这样的：

        首先调用 setjmp() 函数来初始化 jmp_buf 结构变量 jmpb，将当前CPU中的大部分影响到程序执行的积存器存入 jmpb，为 longjmp() 函数提供跳转，setjmp() 函数是一个有趣的函数，它能返回两次，它应该是所有库函数中唯一一个能返回两次的函数，第一次是初始化时，返回零，第二次遇到 longjmp() 函数调用后，longjmp() 函数使 setjmp() 函数发生第二次返回，返回值由 longjmp() 的第二个参数给出（整型，这时不应该再返回零）。 

        在使用 setjmp() 初始化 jmpb 后，可以其后的程序中任意地方使用 longjmp() 函数跳转会 setjmp() 函数的位置，longjmp() 的第一个参数便是 setjmp() 初始化的 jmpb，若想跳转回刚才设置的 setjmp() 处，则 longjmp() 函数的第一个参数是 setjmp() 所初始化的 jmpb 这个异常，这也说明一件事，即 jmpb 这个异常，一般需要定义为全局变量，否则，若是局部变量，当跨函数调用时就几乎无法使用（除非每次遇到函数调用都将 jmpb 以参数传递，然而明显地，是不值得这样做的）；longjmp() 函数的第二个参数是传给 setjmp() 的第二次返回值。