前言

本文主要总结嵌入式系统C语言编程中，主要的错误处理方式。文中涉及的代码运行环境如下：
- @7 O; ], K$ O( U& C

一、错误概念

. K! Q; b$ V! ~) i1 [

1.1 错误分类

7 A3 j2 Q6 z: G4 i: o

从严重性而言，程序错误可分为致命性和非致命性两类。对于致命性错误，无法执行恢复动作，最多只能在用户屏幕上打印出错消息或将其写入日志文件，然后终止程序；而对于非致命性错误，多数本质上是暂时的(如资源短缺)，一般恢复动作是延迟一些时间后再次尝试。
从交互性而言，程序错误可分为用户错误和内部错误两类。用户错误呈现给用户，通常指明用户操作上的错误；而程序内部错误呈现给程序员(可能携带用户不可接触的数据细节)，用于查错和排障。
应用程序开发者可决定恢复哪些错误以及如何恢复。例如，若磁盘已满，可考虑删除非必需或已过期的数据；若网络连接失败，可考虑短时间延迟后重建连接。选择合理的错误恢复策略，可避免应用程序的异常终止，从而改善其健壮性。
1.2 处理步骤

错误处理即处理程序运行时出现的任何意外或异常情况。典型的错误处理包含五个步骤：
5 W8 d) u$ J6 O1 X" k3 T

• 程序执行时发生软件错误。该错误可能产生于被底层驱动或内核映射为软件错误的硬件响应事件(如除零)。
• 以一个错误指示符(如整数或结构体)记录错误的原因及相关信息。
• 程序检测该错误(读取错误指示符，或由其主动上报）；
• 程序决定如何处理错误(忽略、部分处理或完全处理)；
• 恢复或终止程序的执行。
  

3 t% R% Q; {3 Q% d1 Z) y上述步骤用C语言代码表述如下：
8 v' J; O$ r4 |* Y" X

1. 
   
2. int func()
   
3. {
   
4.     int bIsErrOccur = 0;
   6 a3 i3 T- B7 n' V0 H$ B+ N& f
5.     //do something that might invoke errors
   ' G8 e3 u. y  P) u( X
6.     if(bIsErrOccur)  //Stage 1: error occurred
   - N* j6 h9 }6 a, V
7.         return -1;   //Stage 2: generate error indicator
   
8.     //...
   : f% u) I) `, B: N  k! A
9.     return 0;
   
10. }
      H5 R; r$ `- Y- I
11. 
    / n: J+ w  O' t1 W) @
12. int main(void)
    
13. {
    
14.     if(func() != 0)  //Stage 3: detect error
    % F: h& C0 O4 F' O
15.     {
    
16.         //Stage 4: handle error
    
17.     }
    ; p. A/ A( d% }! l7 v
18.     //Stage 5: recover or abort
    
19.     return 0;
    ; q! T/ y' m0 R" w2 K9 x4 H) U# l2 L
20. }

复制代码

* j3 q' ^; K9 V4 H. d调用者可能希望函数返回成功时表示完全成功，失败时程序恢复到调用前的状态(但被调函数很难保证这点)。
# n+ Z& v2 Z: h: R二 、错误传递

2.1 返回值和回传参数

/ b) V1 K0 c" N

C语言通常使用返回值来标志函数是否执行成功，调用者通过if等语句检查该返回值以判断函数执行情况。常见的几种调用形式如下：
# r* I* ~3 K+ a  ^) O* G

1. 
   ' B; i$ a) i) d. Q6 h$ q* |% j8 }
2. if((p = malloc(100)) == NULL)
   ) R1 t; d% b: U* f
3.    //...
   & b# _7 s+ u6 S" h& l# k
4. 
   3 a% @; K) d9 f) m* T3 \
5. if((c = getchar()) == EOF)
   
6.    //...
   % ^  V9 r# y1 q9 c9 p& l" Q
7. 
   
8. if((ticks = clock()) < 0)
   " W* p+ s, h' O, \) p
9.    //...

复制代码

  H, h3 w- {5 M3 L' LUnix系统调用级函数(和一些老的Posix函数)的返回值有时既包括错误代码也包括有用结果。因此，上述调用形式可在同一条语句中接收返回值并检查错误(当执行成功时返回合法的数据值)。
$ ^3 d/ v  d" I  H; _9 H返回值方式的好处是简便和高效，但仍存在较多问题：
- m1 {  M( u5 r. {+ T5 [, K

• 代码可读性降低
  * S9 a+ D4 [; e: Q
  

没有返回值的函数是不可靠的。但若每个函数都具有返回值，为保持程序健壮性，就必须对每个函数进行正确性验证，即调用时检查其返回值。这样，代码中很大一部分可能花费在错误处理上，且排错代码和正常流程代码搅在一起，比较混乱。
7 \' X9 B: _0 C% ?$ a9 t5 x# q# L

• 质量降级
  ; ]* l/ V# _7 z. V

条件语句相比其他类型的语句潜藏更多的错误。不必要的条件语句会增加排障和白盒测试的工作量。

• 信息有限
  

通过返回值只能返回一个值，因此一般只能简单地标志成功或失败，而无法作为获知具体错误信息的手段。通过按位编码可变通地返回多个值，但并不常用。字符串处理函数可参考IntToAscii()来返回具体的错误原因，并支持链式表达：

1. 
   / P7 A: B" U: @) a
2. char *IntToAscii(int dwVal, char *pszRes, int dwRadix)
   6 D: j: t) ?4 H0 B5 ?- G: i
3. {
   3 k+ ^- X  ~( q/ Z" o
4.     if(NULL == pszRes)
   0 |0 d$ E: P7 d' J/ p
5.         return "Arg2Null";
   % r5 ^( {. q* y5 _$ v, S' ]
6. 
   7 `. `5 w  ^' t; I7 G) \) g
7.     if((dwRadix < 2) || (dwRadix > 36))
   4 P3 c3 Z3 Y% T4 C6 {4 ?
8.         return "Arg3OutOfRange";
   
9. 
   ) A9 g' }( X3 L# ?
10.     //...
    
11.     return pszRes;
    $ F, r- }  O0 b: j/ A- O, X
12. }

复制代码

  O* h( B5 N/ x! n" K( j

• 定义冲突
  

% `) ?1 p  r2 n7 L( z+ @% i& \不同函数在成功和失败时返回值的取值规则可能不同。例如，Unix系统调用级函数返回0代表成功，-1代表失败；新的Posix函数返回0代表成功，非0代表失败；标准C库中isxxx函数返回1表示成功，0表示失败。

• 无约束性
  

  m! C: w1 o6 |. {& h/ g调用者可以忽略和丢弃返回值。未检查和处理返回值时，程序仍然能够运行，但结果不可预知。
2 Z; `7 ]- e+ P新的Posix函数返回值只携带状态和异常信息，并通过参数列表中的指针回传有用的结果。回传参数绑定到相应的实参上，因此调用者不可能完全忽略它们。通过回传参数(如结构体指针)可返回多个值，也可携带更多的信息。
综合返回值和回传参数的优点，可对Get类函数采用返回值(含有用结果)方式，而对Set类函数采用返回值+回传参数方式。对于纯粹的返回值，可按需提供如下解析接口：

1. 
   
2. typedef enum{
   
3.     S_OK,               //成功
   
4.     S_ERROR,            //失败(原因未明确)，通用状态
   
5.     S_NULL_POINTER,     //入参指针为NULL
   ; X8 ]# p- g4 c- y
6.     S_ILLEGAL_PARAM,    //参数值非法，通用
   
7.     S_OUT_OF_RANGE,     //参数值越限
   8 \6 _. p- |$ T9 P9 @
8.     S_MAX_STATUS        //不可作为返回值状态，仅作枚举最值使用
   
9. }FUNC_STATUS;
   
10. 
    
11. #define RC_NAME(eRetCode) \
    
12.     ((eRetCode) == S_OK                   ?    "Success"             : \
    
13.     ((eRetCode) == S_ERROR                ?    "Failure"             : \
    - E5 b+ t  K6 o4 M% N- g; {7 h
14.     ((eRetCode) == S_NULL_POINTER         ?    "NullPointer"         : \
    ' |6 v  T- r' d
15.     ((eRetCode) == S_ILLEGAL_PARAM        ?    "IllegalParas"        : \
    ) p  f5 Z; C0 U$ E- y0 J
16.     ((eRetCode) == S_OUT_OF_RANGE         ?    "OutOfRange"          : \
    % ]! z4 P, w* d9 q
17.       "Unknown")))))

复制代码

当返回值错误码来自下游模块时，可能与本模块错误码冲突。此时，建议不要将下游错误码直接向上传递，以免引起混乱。若允许向终端或文件输出错误信息，则可详细记录出错现场(如函数名、错误描述、参数取值等)，并转换为本模块定义的错误码再向上传递。
2.2 全局状态标志(errno)

% o, w5 W" z8 d( F: M

Unix系统调用或某些C标准库函数出错时，通常返回一个负值，并设置全局整型变量errno为一个含有错误信息的值。例如，open函数出错时返回-1，并设置errno为EACESS(权限不足)等值。
C标准库头文件<errno.h>中定义errno及其可能的非零常量取值(以字符'E'开头)。在ANSI C中已定义一些基本的errno常量，操作系统也会扩展一部分(但其对错误描述仍显匮乏)。
Linux系统中，出错常量在errno(3)手册页中列出，可通过man 3 errno命令查看。除EAGAIN和EWOULDBLOCK取值相同外，POSIX.1指定的所有出错编号取值均不同。
Posix和ISO C将errno定义为一个可修改的整型左值(lvalue)，可以是包含出错编号的一个整数，或是一个返回出错编号指针的函数。以前使用的定义为：
( E. k6 m# q2 `) D+ d% q0 B3 J

1. 
   2 C3 H+ [) `9 m( B
2. extern int errno;

复制代码

$ ~8 H  r0 a% o/ L! f6 P但在多线程环境中，多个线程共享进程地址空间，每个线程都有属于自己的局部errno(thread-local)以避免一个线程干扰另一个线程。例如，Linux支持多线程存取errno，将其定义为：
! p9 c2 a) G) o9 U5 Q, O/ T

1. 
   
2. extern int *__errno_location(void);
   
3. #define errno (*__errno_location())

复制代码

函数__errno_location在不同的库版本下有不同的定义，在单线程版本中，直接返回全局变量errno的地址；而在多线程版本中，不同线程调用__errno_location返回的地址则各不相同。
1 M. }5 P8 p; s# G' u. BC运行库中主要在math.h(数学运算)和stdio.h(I/O操作)头文件声明的函数中使用errno。
使用errno时应注意以下几点：

• 函数返回成功时，允许其修改errno。
  

3 R; {/ ~4 C* b! s5 x例如，调用fopen函数新建文件时，内部可能会调用其他库函数检测是否存在同名文件。而用于检测文件的库函数在文件不存在时，可能会失败并设置errno。这样， fopen函数每次新建一个事先并不存在的文件时，即使没有任何程序错误发生(fopen本身成功返回)，errno也仍然可能被设置。
8 L' u/ \0 S2 T2 d3 y因此，调用库函数时应先检测作为错误指示的返回值。仅当函数返回值指明出错时，才检查errno值：
) n# d& f4 i. ^" f

1. 
   6 H: |  J7 `5 z7 X1 |4 G
2. //调用库函数
   ( _. _7 C( |, e3 x) U) @: ^9 O8 U
3. if(返回错误值)
   
4.     //检查errno

复制代码

! Q& ^# }. S2 d' c3 |

• 库函数返回失败时，不一定会设置errno，取决于具体的库函数。
  
  6 O2 m; ]2 F! K2 N
• errno在程序开始时设置为0，任何库函数都不会将errno再次清零。
  

因此，在调用可能设置errno的运行库函数之前，最好先将errno设置为0。调用失败后再检查errno的值。

• 使用errno前，应避免调用其他可能设置errno的库函数。如：
  

1. 
   & b+ Q) R& ]# t0 V
2. if (somecall() == -1)
   1 ~9 {( r6 h3 A7 a# f3 {4 U# ]
3. {
   
4.     printf("somecall() failed\n");
   
5.     if(errno == ...) { ... }
   
6. }

复制代码

somecall()函数出错返回时设置errno。但当检查errno时，其值可能已被printf()函数改变。若要正确使用somecall()函数设置的errno，须在调用printf()函数前保存其值：
9 ?" Z! V- k: N! f" n( M

1. 
   
2. if (somecall() == -1)
   
3. {
   $ M' K! ?" D* e' o
4.     int dwErrSaved = errno;
   
5.     printf("somecall() failed\n");
     j4 V2 N" y* J0 p! D1 ~
6.     if(dwErrSaved == ...) { ... }
   3 J7 l# O0 u0 ~$ \5 |4 _
7. }

复制代码

类似地，当在信号处理程序中调用可重入函数时，应在其前保存其后恢复errno值。

• 使用现代版本的C库时，应包含使用<errno.h>头文件；在非常老的Unix 系统中，可能没有该头文件，此时可手工声明errno(如extern int errno)。
  + y7 {% r( t% H/ W9 f0 K

C标准定义strerror和perror两个函数，以帮助打印错误信息。

1. 
   
2. #include <string.h>
   ) Q) g. q5 y- i- ?: U& T8 |$ k! Y+ D
3. char *strerror(int errnum);

复制代码

该函数将errnum(即errno值)映射为一个出错信息字符串，并返回指向该字符串的指针。可将出错字符串和其它信息组合输出到用户界面，或保存到日志文件中，如通过fprintf(fp, "somecall failed(%s)", strerror(errno))将错误消息打印到fp指向的文件中。
perror函数将当前errno对应的错误消息的字符串输出到标准错误(即stderr或2)上。
( k4 S  w/ `3 f0 d) |

1. 
   4 R" p; X) m( @3 D3 s; K, W5 ~) k/ }
2. #include <stdio.h>
   - e1 N5 D8 T5 J9 e7 x, z  }
3. void perror(const char *msg);

复制代码

- f% g0 s0 g+ E8 u该函数首先输出由msg指向的字符串(用户自己定义的信息)，后面紧跟一个冒号和空格，然后是当前errno值对应的错误类型描述，最后是一个换行符。未使用重定向时，该函数输出到控制台上；若将标准错误输出重定向到/dev/null，则看不到任何输出。
. R2 _& M0 v2 Z0 _注意，perror()函数中errno对应的错误消息集合与strerror()相同。但后者可提供更多定位信息和输出方式。
两个函数的用法示例如下：
( I6 P+ p( b' P' S1 B5 _+ G/ r0 G

1. 
   1 Q$ K& p% H! }
2. int main(int argc, char** argv)
   7 i0 x8 K2 V; c$ g) W7 y9 M
3. {
   
4.     errno = 0;
   
5.     FILE *pFile = fopen(argv[1], "r");
   
6.     if(NULL == pFile)
   
7.     {
   4 m6 _# U3 z# ~2 f9 J
8.         printf("Cannot open file '%s'(%s)!\n", argv[1], strerror(errno));
   
9.         perror("Open file failed");
   ) E7 U# P4 {$ ?4 F1 o
10.     }
    
11.     else
    2 }# H5 V0 `) b- N
12.     {
    1 D6 O- g4 g1 Q5 q) C) b* p* N
13.         printf("Open file '%s'(%s)!\n", argv[1], strerror(errno));
    : }! y8 W: A) p5 t
14.         perror("Open file");
    ' R5 [3 r( G8 J* h5 j( Z! i+ K+ K
15.         fclose(pFile);
    9 E2 |( X$ J8 g6 V4 k7 m% Y9 Q3 J
16.     }
    
17. 
    # {+ S5 o" u( x  F# O
18.     return 0;
    
19. }

复制代码

执行结果为：
( o( I) I4 d7 v( c

1. 
   3 D7 x2 B8 _$ I% ^3 ?" W
2. [wangxiaoyuan_@localhost test1]$ ./GlbErr /sdb1/wangxiaoyuan/linux_test/test1/test.c
   
3. Open file '/sdb1/wangxiaoyuan/linux_test/test1/test.c'(Success)!
   5 o# ^* }4 o4 s
4. Open file: Success
   
5. [wangxiaoyuan_@localhost test1]$ ./GlbErr NonexistentFile.h
   
6. Cannot open file 'NonexistentFile.h'(No such file or directory)!
   6 d- R( m6 a1 C& M6 _! K
7. Open file failed: No such file or directory
   ( e; l1 w9 ?! p! ^
8. [wangxiaoyuan_@localhost test1]$ ./GlbErr NonexistentFile.h > test
   , P' r: O" z+ W/ D3 N  G
9. Open file failed: No such file or directory
   : |0 |- C  q4 Y( d, V. v- q0 s
10. [wangxiaoyuan_@localhost test1]$ ./GlbErr NonexistentFile.h 2> test
    0 K3 \% V4 D- t6 |3 `% B
11. Cannot open file 'NonexistentFile.h'(No such file or directory)!

复制代码

% \6 o8 o% g4 i) g也可仿照errno的定义和处理，定制自己的错误代码：
7 M6 x$ D5 c5 A3 |+ P

1. 
   
2. int *_fpErrNo(void)
   
3. {
   # R+ Z* t- c" y5 Y" V
4.    static int dwLocalErrNo = 0;
   
5.    return &dwLocalErrNo;
   ! O- f( w/ F% n$ n
6. }
   $ Z; f+ I) S# N! x
7. 
   
8. #define ErrNo (*_fpErrNo())
   
9. #define EOUTOFRANGE  1
   $ E4 l$ v0 E3 _5 a; e/ U
10. //define other error macros...
    
11. 
      c' y5 u6 ?, q' ~
12. int Callee(void)
    
13. {
    % r; W+ h7 p4 j9 I* ?
14.     ErrNo = 1;
    " Z* |9 i4 a: e" @/ s
15.     return -1;
    % u2 l! R" h2 G, R* u, l# K1 w/ _
16. }
    : |& |1 M+ W# _+ n1 V
17. 
    
18. int main(void)
    
19. {
    ; b; r! a: |/ O5 R  Y" l- T0 `/ j' f
20.     ErrNo = 0;
    
21.     if((-1 == Callee()) && (EOUTOFRANGE == ErrNo))
    
22.         printf("Callee failed(ErrNo:%d)!\n", ErrNo);
    
23.     return 0;
    3 a! Q& q1 Q! B- n& m" u' m- h
24. }

复制代码

借助全局状态标志，可充分利用函数的接口(返回值和参数表)。但与返回值一样，它隐含地要求调用者在调用函数后检查该标志，而这种约束同样脆弱。
此外，全局状态标志存在重用和覆盖的风险。而函数返回值是无名的临时变量，由函数产生且只能被调用者访问。调用完成后即可检查或拷贝返回值，然后原始的返回对象将消失而不能被重用。又因为无名，返回值不能被覆盖。
+ Q$ f5 U( B+ t3 j+ ]& ?2.3 局部跳转(goto)

使用goto语句可直接跳转到函数内的错误处理代码处。以除零错误为例：

1. 
   5 G0 W! L- R+ p; ]
2. double Division(double fDividend, double fDivisor)
   ; h3 `" z3 @/ W/ X0 h9 D
3. {
   1 m+ O  C+ L0 h
4.     return fDividend/fDivisor;
   & s- Q- M4 e, E6 P8 r2 \
5. }
   9 ^% Y" `# _, u0 H; R8 X: L
6. int main(void)
   
7. {
   
8.     int dwFlag = 0;
   
9.     if(1 == dwFlag)
   
10.     {
    
11.     RaiseException:
    
12.         printf("The divisor cannot be 0!\n");
    # c+ |, R3 u1 d+ ~
13.         exit(1);
    
14.     }
    
15.     dwFlag = 1;
    % ?7 o/ _% F* D7 C6 m
16. 
    # l9 r% \8 w) o1 t6 P
17.     double fDividend = 0.0, fDivisor = 0.0;
      e2 o( S/ J9 U) p* {5 E( B
18.     printf("Enter the dividend: ");
    ( N$ m9 m: |' c
19.     scanf("%lf", &fDividend);
    
20.     printf("Enter the divisor : ");
      @- ?% Y5 M3 [' ~; ]* v
21.     scanf("%lf", &fDivisor);
      w8 G* r4 G0 C" S
22.     if(0 == fDivisor) //不太严谨的浮点数判0比较
    $ y9 {6 `* O: x5 w, }
23.         goto RaiseException;
    & f  W4 k9 R! ~5 J7 l1 O6 V
24.     printf("The quotient is %.2lf\n", Division(fDividend, fDivisor));
    
25. 
    2 g* P* `( i3 z; C
26.     return 0;
    5 {& ^% p! ?  T8 \$ p# A# B) W
27. }

复制代码

# k/ U3 ~" ?: f2 ^3 F& R执行结果如下：
) A# k' u- c, \# o& n+ x$ y

1. 
   8 D2 `+ H) h+ b5 }
2. [wangxiaoyuan_@localhost test1]$ ./test
   # I* L4 @: {/ O% e
3. Enter the dividend: 10
   . G0 n1 [, ^; t" u0 w9 S0 Q
4. Enter the divisor : 0
   $ v9 y0 G- M' C
5. The divisor cannot be 0!
   ! Z6 p% I! a% s6 N6 D: |: d
6. [wangxiaoyuan_@localhost test1]$ ./test
   # C3 P: v9 v; y6 p" _
7. Enter the dividend: 10
   
8. Enter the divisor : 2
   4 t  p! X5 y. W7 r" J
9. The quotient is 5.00
   % Y8 a) l2 ]/ g( i- I4 l4 N
10. 虽然goto语句会破坏代码结构性，但却非常适用于集中错误处理。伪代码示例如下：
    . M# n- s; a" x7 A9 o
11. CallerFunc()
    
12. {
    ( I6 H9 M7 i' U9 D; z
13.     if((ret = CalleeFunc1()) < 0);
    
14.         goto ErrHandle;
    ; p+ y3 x/ _  ?1 ^4 M4 G
15.     if((ret = CalleeFunc2()) < 0);
    
16.         goto ErrHandle;
    0 k% z, p8 x5 F# e! `5 u! B
17.     if((ret = CalleeFunc3()) < 0);
    
18.         goto ErrHandle;
    : L2 k( K/ g. ^: T4 t  K
19.     //...
    / A2 @* `1 g1 b; U; |! N
20. 
    ' ~9 A0 ?- ~! f- o- d
21.     return;
    
22. 
    ) h7 I5 L% x1 }
23. ErrHandle:
    7 [# U4 o; T5 Q" f. o
24.     //Handle Error(e.g. printf)
    . E8 f) P: {' \5 Z& q- _
25.     return;
    & Y; R" I. `+ C" g
26. }

复制代码

# [1 i" g/ d, k; l3 O& S& v2.4 非局部跳转(setjmp/longjmp)

) D4 P7 O4 n; S1 }+ p  V. }

局部goto语句只能跳到所在函数内部的标号上。若要跨越函数跳转，需要借助标准C库提供非局部跳转函数setjmp()和longjmp()。它们分别承担非局部标号和goto的作用，非常适用于处理发生在深层嵌套函数调用中的出错情况。“非局部跳转”是在栈上跳过若干调用帧，返回到当前函数调用路径上的某个函数内。
" {8 n  v. c4 G

1. 
   5 A7 x9 d' t( o9 ?. V
2. #include <setjmp.h>
   . ]5 P" ]' B' Z9 @3 F& Z5 R* }+ h
3. int setjmp(jmp_buf env);
   
4. void longjmp(jmp_buf env,int val);

复制代码

  W' e$ l/ X, U, r函数setjmp()将程序运行时的当前系统堆栈环境保存在缓冲区env结构中。初次调用该函数时返回值为0。longjmp()函数根据setjmp()所保存的env结构恢复先前的堆栈环境，即“跳回”先前调用setjmp时的程序执行点。此时，setjmp()函数返回longjmp()函数所设置的参数val值，程序将继续执行setjmp调用后的下一条语句(仿佛从未离开setjmp)。参数val为非0值，若设置为0，则setjmp()函数返回1。可见，setjmp()有两类返回值，用于区分是首次直接调用(返回0)和还是由其他地方跳转而来(返回非0值)。对于一个setjmp可有多个longjmp，因此可由不同的非0返回值区分这些longjmp。
举个简单例子说明 setjmp/longjmp的非局部跳转：

1. 
   2 [# X: @9 M; g
2. jmp_buf gJmpBuf;
   
3. void Func1(){
   4 y$ u- J& |$ D  `& I9 j) ~9 L8 F
4.     printf("Enter Func1\n");
   
5.     if(0)longjmp(gJmpBuf, 1);
   
6. }
   7 l1 |: D4 q0 r1 k. v# _3 r
7. void Func2(){
   ( j1 @6 ]& @" W6 A/ {( t, R
8.     printf("Enter Func2\n");
   
9.     if(0)longjmp(gJmpBuf, 2);
     P/ @$ a% u; ^/ w  h2 E
10. }
    
11. void Func3(){
    * W- C0 g# w+ o& K) b  Q
12.     printf("Enter Func3\n");
    
13.     if(1)longjmp(gJmpBuf, 3);
    4 R  u: ?& O2 E5 v
14. }
    ' j1 h3 m# }' W0 ^
15. 
    3 p/ _) ~$ H$ L3 |) j
16. int main(void)
    
17. {
    
18.     int dwJmpRet = setjmp(gJmpBuf);
    1 S2 N* v1 h+ }* l
19.     printf("dwJmpRet = %d\n", dwJmpRet);
    
20.     if(0 == dwJmpRet)
    
21.     {
    $ j# a, H5 ?: x) o0 _
22.         Func1();
    
23.         Func2();
    ' W+ O. q+ T5 Y0 ]( E
24.         Func3();
    9 \# ?* }+ C: `$ @% o7 R; x
25.     }
    
26.     else
    ; o2 Q6 p, }' Y9 r% L. q. _
27.     {
    
28.         switch(dwJmpRet)
    
29.         {
    
30.             case 1:
    / M7 c2 U& p' k1 u  n. x
31.                 printf("Jump back from Func1\n");
    
32.             break;
    
33.             case 2:
    4 P. h) x' z' `
34.                 printf("Jump back from Func2\n");
    8 F' z" ^6 K' b0 {; I6 x
35.             break;
    
36.             case 3:
    
37.                 printf("Jump back from Func3\n");
    3 _4 ?: ]% J! U6 Y# T
38.             break;
    / h+ o6 z8 |4 M  w: Q
39.             default:
    
40.                 printf("Unknown Func!\n");
    $ ^7 E  f8 S% G  M# z7 M
41.             break;
    
42.         }
    
43.     }
    + z  @1 j1 R% }/ }* P
44.     return 0;
    - k8 d$ [: F( b" m0 {
45. }

复制代码

执行结果为：
" b1 `5 J- r* x/ [  M4 d8 \

1. 
   
2. dwJmpRet = 0
   3 O5 B9 D, ]/ |) k: [) w4 X# @
3. Enter Func1
   / x! z$ q  M4 w
4. Enter Func2
   . s8 B/ @+ g! e' g( U
5. Enter Func3
   4 ]: S8 ^+ c, @* o6 N+ A
6. dwJmpRet = 3
   4 E& t( C& S/ ^% {) I
7. Jump back from Func3

复制代码

当setjmp/longjmp嵌在单个函数中使用时，可模拟PASCAL语言中嵌套函数定义(即函数内中定义一个局部函数)。当setjmp/longjmp跨越函数使用时，可模拟面向对象语言中的异常(exception) 机制。
# h) ?9 {8 \+ m+ v& Y模拟异常机制时，首先通过setjmp()函数设置一个跳转点并保存返回现场，然后使用try块包含那些可能出现错误的代码。可在try块代码中或其调用的函数内，通过longjmp()函数抛出(throw)异常。抛出异常后，将跳回setjmp()函数所设置的跳转点并执行catch块所包含的异常处理程序。
8 B" K, I6 F/ N* h# ~以除零错误为例：
9 m. T) h9 I& Z) O

1. 
   8 z% Z# G3 H+ \) n8 W
2. jmp_buf gJmpBuf;
   
3. void RaiseException(void)
   ) l1 c" J+ _. y& C7 w& E
4. {
   " v7 ^7 @8 d- y1 K7 e8 R+ L( t& D$ f
5.    printf("Exception is raised: ");
   
6.    longjmp(gJmpBuf, 1);  //throw，跳转至异常处理代码
   , ]2 l/ s/ N! u1 |0 [. }+ S
7.    printf("This line should never get printed!\n");
   4 B' e* ~0 C) ~/ ]; [0 N0 B4 W/ C
8. }
   
9. double Division(double fDividend, double fDivisor)
   
10. {
    / v  ~7 m. P/ z$ \5 u- |
11.     return fDividend/fDivisor;
    7 {* P+ @2 @9 b  U- M  B, [) e
12. }
    
13. int main(void)
    
14. {
    3 A& l# t  |8 |* F7 W+ Z- z# U
15.     double fDividend = 0.0, fDivisor = 0.0;
    - G$ }9 Z6 d. J$ m1 O
16.     printf("Enter the dividend: ");
    
17.     scanf("%lf", &fDividend);
    8 v) V: L' b2 ]  c% L! O0 _$ \
18.     printf("Enter the divisor : ");
    
19.     if(0 == setjmp(gJmpBuf))  //try块
    
20.     {
    4 |4 Z9 I+ b/ h, x* t; u
21.         scanf("%lf", &fDivisor);
    
22.         if(0 == fDivisor) //也可将该判断及RaiseException置于Division内
    
23.             RaiseException();
    / S' H9 {3 K1 y2 K% `. f
24.         printf("The quotient is %.2lf\n", Division(fDividend, fDivisor));
    5 o% I0 l" L; V% C# N) P
25.     }
    
26.     else  //catch块(异常处理代码)
    
27.     {
    0 o3 |2 s5 C: |
28.         printf("The divisor cannot be 0!\n");
    
29.     }
    0 w! k  p  \( w1 t* Z$ H" ?5 I
30. 
    ) N+ s; }( Q6 W- p8 |" G
31.     return 0;
    4 O% [& G: C5 R5 `7 J/ A: L! n0 G8 [
32. }

复制代码

执行结果为：

1. 
   1 G8 t2 G5 s1 y" m; z
2. Enter the dividend: 10
   , p: `& E% ^" u* R# T; o; n
3. Enter the divisor : 0
   8 h. u0 \4 j& ]  u# x9 Z
4. Exception is raised: The divisor cannot be 0!

复制代码

4 d4 |* Y- f, v" @( d3 B通过组合使用setjmp/longjmp函数，可对复杂程序中可能出现的异常进行集中处理。根据longjmp()函数所传递的返回值来区分处理各种不同的异常。
5 a; q: U+ X0 q2 \1 P使用setjmp/longjmp函数时应注意以下几点：
$ {) \6 \/ ?1 W2 u1 D

• 必须先调用setjmp()函数后调用longjmp()函数，以恢复到先前被保存的程序执行点。若调用顺序相反，将导致程序的执行流变得不可预测，很容易导致程序崩溃。
• longjmp()函数必须在setjmp()函数的作用域之内。在调用setjmp()函数时，它保存的程序执行点环境只在当前主调函数作用域以内(或以后)有效。若主调函数返回或退出到上层(或更上层)的函数环境中，则setjmp()函数所保存的程序环境也随之失效(函数返回时堆栈内存失效)。这就要求setjmp()不可该封装在一个函数中，若要封装则必须使用宏(详见《C语言接口与实现》“第4章 异常与断言”)。
• 通常将jmp_buf变量定义为全局变量，以便跨函数调用longjmp。
• 通常，存放在存储器中的变量将具有longjmp时的值，而在CPU和浮点寄存器中的变量则恢复为调用setjmp时的值。因此，若在调用setjmp和longjmp之间修改自动变量或寄存器变量的值，当setjmp从longjmp调用返回时，变量将维持修改后的值。若要编写使用非局部跳转的可移植程序，必须使用volatile属性。
• 使用异常机制不必每次调用都检查一次返回值，但因为程序中任何位置都可能抛出异常，必须时刻考虑是否捕捉异常。在大型程序中，判断是否捕捉异常会是很大的思维负担，影响开发效率。相比之下，通过返回值指示错误有利于调用者在最近出错的地方进行检查。此外，返回值模式中程序的运行顺序一目了然，对维护者可读性更高。因此，应用程序中不建议使用setjmp/longjmp“异常处理”机制(除非库或框架)。
  

2.5 信号(signal/raise)在某些情况下，主机环境或操作系统可能发出信号(signal)事件，指示特定的编程错误或严重事件(如除0或中断等)。这些信号本意并非用于错误捕获，而是指示与正常程序流不协调的外部事件。
4 P" L$ |. C1 i: ]2 X为处理信号，需要使用以下信号相关函数：

1. 
   
2. #include <signal.h>
   
3. typedef void (*fpSigFunc)(int);
   & K  m9 Q3 S1 v# r7 t  N$ v
4. fpSigFunc signal(int signo, fpSigFunc fpHandler);
   ! {2 a2 @# l3 R. I+ l0 g
5. int raise(int signo);

复制代码

( Q. l0 ]: X0 ^. ?其中，参数signo是Unix系统定义的信号编号(正整数)，不允许用户自定义信号。参数fpHandler是常量SIG_DFL、常量SIG_IGN或当接收到此信号后要调用的信号处理函数(signal handler)的地址。若指定SIG_DFL，则接收到此信号后调用系统的缺省处理函数；若指定SIG_ IGN，则向内核表明忽略此信号(SIGKILL和SIGSTOP不可忽略)。某些异常信号(如除数为零)不太可能恢复，此时信号处理函数可在程序终止前正确地清理某些资源。信号处理函数所收到的异常信息仅是一个整数(待处理的信号事件)，这点与setjmp()函数类似。
signal()函数执行成功时返回前次挂接的处理函数地址，失败时则返回SIG_ERR。信号通过调用raise()函数产生并被处理函数捕获。
6 F$ n# u( q, W9 Z/ ]以除零错误为例：

1. 
   
2. void fphandler(int dwSigNo)
   
3. {
   
4.     printf("Exception is raised, dwSigNo=%d!\n", dwSigNo);
   - a  T9 Y( @+ k
5. }
   
6. int main(void)
   
7. {
   8 d: N- {- Z2 A6 X+ K% T% F( `2 L
8.     if(SIG_ERR == signal(SIGFPE, fphandler))
   
9.     {
   
10.         fprintf(stderr, "Fail to set SIGFPE handler!\n");
    
11.         exit(EXIT_FAILURE);
    
12.     }
    ) G6 S2 G, L4 v; B* v: k, C
13. 
    
14.     double fDividend = 10.0, fDivisor = 0.0;
    
15.     if(0 == fDivisor)
    0 A9 W& d) r# ]# p1 M2 s: c' h( |& E" h
16.     {
    
17.         raise(SIGFPE);
    
18.         exit(EXIT_FAILURE);
    
19.     }
    
20.     printf("The quotient is %.2lf\n", fDividend/fDivisor);
    - w, Q0 V; V! B) F" J1 ~
21. 
    " B4 S+ i6 }4 u7 z/ V: g, x
22.     return 0;
    
23. }

复制代码

执行结果为"Exception is raised, dwSigNo=8!"(0.0不等同于0，因此系统未检测到浮点异常)。
# V3 x4 w& u  Z若将被除数(Dividend)和除数(Divisor)改为整型变量：

1. 
   ' z/ z$ G1 `1 D' p" ^
2. int main(void)
   
3. {
   - ^6 A$ N3 y9 g  L8 }" c! @1 i3 ?
4.     if(SIG_ERR == signal(SIGFPE, fphandler))
   
5.     {
   1 S$ t$ h7 J* ^: L1 B2 x" h: D
6.         fprintf(stderr, "Fail to set SIGFPE handler!\n");
     I4 r0 ~1 j; a+ U
7.         exit(EXIT_FAILURE);
   ; y0 g4 b" b/ Y% g% @$ @4 ]
8.     }
   3 e6 q7 M& d9 {  D# {" B
9. 
   
10.     int dwDividend = 10, dwDivisor = 0;
    
11.     double fQuotient = dwDividend/dwDivisor;
    
12.     printf("The quotient is %.2lf\n", fQuotient);
    
13. 
    
14.     return 0;
    ' D- L7 t% a4 e5 N! Y# q
15. }

复制代码

则执行后循环输出"Exception is raised, dwSigNo=8!"。这是因为进程捕捉到信号并对其进行处理时，进程正在执行的指令序列被信号处理程序临时中断，它首先执行该信号处理程序中的指令。若从信号处理程序返回(未调用exit或longjmp)，则继续执行在捕捉到信号时进程正在执行的正常指令序列。因此，每次系统调用信号处理函数后，异常控制流还会返回除0指令继续执行。而除0异常不可恢复，导致反复输出异常。
/ ]% k  X! g- q4 Y7 H& ~& [规避方法有两种：
( X0 b. E# _& n: I$ V( ]8 ]8 c

• 将SIGFPE信号变成系统默认处理，即signal(SIGFPE, SIG_DFL)。
  9 _& `' C0 }: V) B

此时执行输出为"Floating point exception"。

• 利用setjmp/longjmp跳过引发异常的指令：
  9 Y# E1 O- B! ]# a" V

1. 
   5 a- n. {9 T( u& [
2. jmp_buf gJmpBuf;
     G, I+ l7 R2 m( n0 u5 U2 R
3. void fphandler(int dwSigNo)
   
4. {
   % Q: A' X% k) R. _, @
5.     printf("Exception is raised, dwSigNo=%d!\n", dwSigNo);
   
6.     longjmp(gJmpBuf, 1);
   / N7 r( o6 W8 ?1 b4 F
7. }
   
8. int main(void)
   . \/ _& [0 O2 q& y! o
9. {
   % P7 T( S2 ^; R* g. @# s
10.     if(SIG_ERR == signal(SIGFPE, SIG_DFL))
    & q7 U; X2 @5 J9 g1 L5 ]
11.     {
    : K1 S! X) e3 C
12.         fprintf(stderr, "Fail to set SIGFPE handler!\n");
    9 D, Z+ t3 f9 y; |, y
13.         exit(EXIT_FAILURE);
    
14.     }
    6 R0 q' n! f, K0 ?. `0 V1 i
15. 
    0 P. N3 P' ~8 D- x( i5 h' R6 Q
16.     int dwDividend = 10, dwDivisor = 0;
    
17.     if(0 == setjmp(gJmpBuf))
    
18.     {
    
19.         double fQuotient = dwDividend/dwDivisor;
    3 e' q# P+ R7 h9 I
20.         printf("The quotient is %.2lf\n", fQuotient);
    4 ~. O1 {1 K, j2 ]! v
21.     }
    2 S5 a. W8 A  W$ @
22.     else
    
23.     {
    % a5 s7 {2 i% u' s  b- H
24.         printf("The divisor cannot be 0!\n");
    / ?) z' i4 V1 e3 o
25.     }
    
26. 
    
27.     return 0;
    
28. }

复制代码

9 A# V4 I' R5 ~' c注意，在信号处理程序中还可使用sigsetjmp/siglongjmp函数进行非局部跳转。相比setjmp函数，sigsetjmp函数增加一个信号屏蔽字参数。
6 [4 f, n( E9 b! d( V6 {三  错误处理

% }) @1 K% \$ K+ @- y& U0 a+ K' M- x

3.1 终止(abort/exit)

致命性错误无法恢复，只能终止程序。例如，当空闲堆管理程序无法提供可用的连续空间时(调用malloc返回NULL)，用户程序的健壮性将严重受损。若恢复的可能性渺茫，则最好终止或重启程序。
1 ~+ h( q2 D% a% T/ U6 v标准C库提供exit()和abort()函数，分别用于程序正常终止和异常终止。两者都不会返回到调用者中，且都导致程序被强行结束。
exit()及其相似函数原型声明如下：
9 y7 {' z: j# d, [  H

1. 
   * X& F, I3 o7 d4 U
2. #include <stdlib.h>
   9 O9 Q) H* r. {2 R
3. void exit(int status);
   0 Q0 Y# {% R) N8 @# n& D- _
4. void _Exit(int status);
   
5. #include <unistd.h>
   
6. void _exit(int status);

复制代码

其中，exit和_Exit由ISO C说明，而_exit由Posix.1说明。因此使用不同的头文件。ISO C定义_Exit旨在为进程提供一种无需运行终止处理程序(exit handler)或信号处理程序(signal handler)而终止的方法，是否冲洗标准I/O流则取决于实现。Unix系统中_Exit 和_exit同义，两者均直接进入内核，而不冲洗标准I/O流。_exit函数由exit调用，处理Unix特定的细节。
exit()函数首先调用执行各终止处理程序，然后按需多次调用fclose函数关闭所有已打开的标准I/O流(将所有缓冲的输出数据冲洗写到文件上)，然后调用_exit函数进入内核。
; i- i( D1 s. K; L: s) b- t标准函数库中有一种“缓冲I/O(buffered I/O)”机制。该机制对于每个打开的文件，在内存中维护一片缓冲区。每次读文件时会连续读出若干条记录，下次读文件时就可直接从内存缓冲区中读取；每次写文件时也仅仅写入内存缓冲区，等满足一定条件(如缓冲区填满，或遇到换行符等特定字符)时再将缓冲区内容一次性写入文件。通过尽可能减少read和write调用的次数，该机制可显著提高文件读写速度，但也给编程带来某些麻烦。例如，向文件内写入一些数据时，若未满足特定条件，数据会暂存在缓冲区内。开发者并不知晓这点，而调用_ exit()函数直接关闭进程，导致缓冲区数据丢失。因此，若要保证数据完整性，必须调用exit()函数，或在调用 _exit()函数前先通过fflush()函数将缓冲区内容写入指定的文件。
例如，调用printf函数(遇到换行符'\n'时自动读出缓冲区中内容)函数后再调用exit：
7 r: ^* K# ~5 t2 C$ N2 A3 y7 N$ Z

1. 
   5 }/ S. V0 G! D$ l
2. int main(void)
   
3. {
   
4.     printf("Using exit...\n");
   
5.     printf("This is the content in buffer");
   . C# A$ z! e" e1 A: g
6.     exit(0);
   
7.     printf("This line will never be reached\n");
   
8. }

复制代码

0 e! @9 n6 T, p: b3 V* C执行输出为：

1. 
   $ @9 w% a% t4 F0 }
2. Using exit...
   $ [9 N* c9 _$ X
3. This is the content in buffer(结尾无换行符)

复制代码

$ t+ @2 C; A% p调用printf函数后再调用_exit：
; G# N8 g7 Y5 s$ I+ f

1. 
   7 N6 ^( Q  G* x$ {9 I3 t
2. int main(void)
   $ X4 F( w9 p, M& T/ B) H
3. {
   7 p8 g/ P3 _, }! d) c6 I% Q0 _
4.     printf("Using _exit...\n");
   . V! v' B; g' R3 k; P
5.     printf("This is the content in buffer");
   # j) l! J, b! v
6.     fprintf(stdout, "Standard output stream");
   : R0 V/ m2 j6 Y6 w, Z; G
7.     fprintf(stderr, "Standard error stream");
     n2 r; s& {* s" o* {: @- x
8.     //fflush(stdout);
   0 [! M+ J. L$ z9 x. |8 L& R
9.     _exit(0);
   ( J8 z* a1 r7 }4 H. H; D
10. }

复制代码

9 t  l( x( q# Q  h5 J* C4 X执行输出为：

1. 
   
2. Using _exit...
   
3. Standard error stream(结尾无换行符)

复制代码

+ E7 y9 ^' ~) X+ M" ]若取消fflush句注释，则执行输出为：

1. 
   # H5 j: s( l3 V
2. Using _exit...
   
3. Standard error streamThis is the content in bufferStandard output stream(结尾无换行符)

复制代码

" ^/ x9 _; a4 e通常，标准错误是不带缓冲的，打开至终端设备的流(如标准输入和标准输出)是行缓冲的(遇换行符则执行I/O操作)；其他所有流则是全缓冲的(填满标准I/O缓冲区后才执行I/O操作)。
三个exit函数都带有一个整型参数status，称之为终止状态(或退出状态)。该参数取值通常为两个宏，即EXIT_SUCCESS(0)和EXIT_FAILURE(1)。大多数Unix shell都可检查进程的终止状态。若(a)调用这些函数时不带终止状态，或(b)main函数执行了无返回值的return语句，或(c) main函数未声明返回类型为整型，则该进程的终止状态未定义。但若main函数的返回类型为整型，且执行到最后一条语句时返回(隐式返回)，则该进程的终止状态为0。
exit系列函数是最简单直接的错误处理方式，但程序出错终止时无法捕获异常信息。ISO C规定一个进程可以注册32个终止处理函数。这些函数可编写为自定义的清理代码，将由exit()函数自动调用，并可使用atexit()函数进行注册。
* p/ o4 R' w: ]# M9 g/ o1 y1 F

1. 
   # q' g! l' B/ V3 j$ c
2. #include <stdlib.h>
   ; R2 g9 Q0 ]6 ^
3. int atexit(void (*func)(void));

复制代码

) v- v+ F/ z" O2 p/ \1 z该函数的参数是一个无参数无返回值的终止处理函数。exit()函数按注册的相反顺序调用这些函数。同一函数若注册多次，则被调用多次。即使不调用exit函数，程序退出时也会执行atexit注册的函数。
* I% t8 Z: G( V1 x. [) i通过结合exit()和atexit()函数，可在程序出错终止时抛出异常信息。以除零错误为例：
9 f; [& c+ @0 N9 _: M* s/ [

1. 
   
2. double Division(double fDividend, double fDivisor)
   
3. {
   
4.     return fDividend/fDivisor;
   - d8 R! l& _7 z- \$ {( D( W& X
5. }
   
6. void RaiseException1(void)
   * q' ~. _9 h7 ^4 C2 Q2 L
7. {
   
8.     printf("Exception is raised: \n");
   
9. }
   4 r! C- u0 H' [
10. void RaiseException2(void)
    ' |7 T* q& j; _9 z$ G. x
11. {
    5 I( {& |) }' W. E
12.     printf("The divisor cannot be 0!\n");
    
13. }
    
14. 
    2 o7 U+ r/ f4 O( ]; _2 n! R
15. int main(void)
    
16. {
    
17.     double fDividend = 0.0, fDivisor = 0.0;
    - L: p9 i- f. O/ w
18.     printf("Enter the dividend: ");
    8 X2 g6 e, T% N/ k( f& v
19.     scanf("%lf", &fDividend);
    8 F/ G' Y+ S4 M8 s( A
20.     printf("Enter the divisor : ");
    ! g( `) T& W3 s' _. [
21.     scanf("%lf", &fDivisor);
    
22.     if(0 == fDivisor)
    
23.     {
    + ~$ q2 q/ e8 X: N$ K
24.         atexit(RaiseException2);
    
25.         atexit(RaiseException1);
    . _7 R: N6 x' b
26.         exit(EXIT_FAILURE);
    3 X. Z. r( r' ~& I6 U# V
27.     }
    
28.     printf("The quotient is %.2lf\n", Division(fDividend, fDivisor));
    
29. 
    3 s. E8 x2 A' H' X
30.     return 0;
    
31. }

复制代码

8 v8 C* g6 z2 [3 ^' L4 O9 U0 E执行结果为：

1. 
   
2. Enter the dividend: 10
   2 u4 v4 @* A- w/ \7 E3 a
3. Enter the divisor : 0
   6 G; i. Z; O( c8 F. G
4. Exception is raised:
   
5. The divisor cannot be 0!

复制代码

8 B) i3 K8 d. I% D6 ], ]% o注意，通过atexit()注册的终止处理函数必须显式(使用return语句)或隐式地正常返回，而不能通过调用exit()或longjmp()等其他方式终止，否则将导致未定义的行为。例如，在GCC4.1.2编译环境下，调用exit()终止时仍等效于正常返回；而VC6.0编译环境下，调用exit()的处理函数将阻止其他已注册的处理函数被调用，并且可能导致程序异常终止甚至崩溃。
+ e# Z) }7 e1 f嵌套调用exit()函数将导致未定义的行为，因此在终止处理函数或信号处理函数中尽量不要调用exit()。
/ @( `$ g' l: |9 e9 S0 Eabort()函数原型声明如下：
5 m. ^' W: t% Q; U# A: Q. _+ @

1. 
   , ]) \; u; b0 y$ a" v) }, g
2. #include <stdlib.h>
   
3. void abort(void);

复制代码

该函数将SIGABRT信号发送给调用进程(进程不应忽略此信号)。ISO C规定，调用abort将向主机环境递送一个未成功终止的通知，其方法是调用raise(SIGABRT)函数。因此，abort()函数理论上的实现为：

1. 
   
2. void abort(void)
   
3. {
   1 X# c! |5 f( ?+ f- M, W
4.     raise(SIGABRT);
   7 W6 P7 v' {) k5 r1 h1 o% q* N
5.     exit(EXIT_FAILURE);
   
6. }

复制代码

! u1 u  C4 ?6 d1 V% r9 i6 ?可见，即使捕捉到SIGABRT信号且相应信号处理程序返回，abort()函数仍然终止程序。Posix.1也说明abort()函数并不理会进程对此信号的阻塞和忽略。
! Y' t" M1 X7 t% F) K- N! u" z进程捕捉到SIGABRT信号后，可在其终止之前执行所需的清理操作(如调用exit)。若进程不在信号处理程序中终止自己，Posix.1声明当信号处理程序返回时，abort()函数终止该进程。
ISO C规定，abort()函数是否冲洗输出流、关闭已打开文件及删除临时文件由实现决定。Posix.1则要求若abort()函数终止进程，则它对所有打开标准I/O流的效果应当与进程终止前对每个流调用fclose相同。为提高可移植性，若希望冲洗标准I/O流，则应在调用abort()之前执行这种操作。
1 u; d/ j% g1 ~3.2 断言(assert)

0 e2 j$ a1 V) K9 U$ J$ g

abort()和exit()函数无条件终止程序。也可使用断言(assert)有条件地终止程序。assert是诊断调试程序时经常使用的宏，定义在<assert.h>内。该宏的典型实现如下：

1. 
   
2. #ifdef    NDEBUG
   
3.     #define assert(expr)        ((void) 0)
   
4. #else
   
5.     extern void __assert((const char *, const char *, int, const char *));
   
6.     #define assert(expr) \
   
7.         ((void) ((expr) || \
   
8.          (__assert(#expr, __FILE__, __LINE__, __FUNCTION__), 0)))
   
9. #endif

复制代码

可见，assert宏仅在调试版本(未定义NDEBUG)中有效，且调用__assert()函数。该函数将输出发生错误的文件名、代码行、函数名以及条件表达式：

1. 
   ) s9 y' y5 ?" M& D3 R
2. void __assert(const char *assertion, const char * filename,
   " Q" A. [* n; Q; T
3.               int linenumber, register const char * function)
   4 t% V" q5 `. A, h' Y" k
4. {
   
5.     fprintf(stderr, " [%s(%d)%s] Assertion '%s' failed.\n",
   
6.             filename, linenumber,
   
7.             ((function == NULL) ? "UnknownFunc" : function),
   : t6 k1 s* c  b. e* A# ?
8.             assertion);
   
9.     abort();
   ; d' q4 r8 [: ]6 Q* |
10. }

复制代码

因此，assert宏实际上是一个带有错误说明信息的abort()，并做了前提条件检查。若检查失败(断言表达式为逻辑假)，则报告错误并终止程序；否则继续执行后面的语句。
9 R* }& M/ u  H+ ^9 `$ c# h- ~, V使用者也可按需定制assert宏。例如，另一实现版本为：
: S6 A. `6 o& v0 [6 }* U1 j3 a

1. 
   , S+ A" T1 |5 x' N3 L
2. #undef assert
   
3. #ifdef NDEBUG
   0 {" Y7 T* ~7 d! u7 m4 {) s+ F
4.     #define assert(expr)        ((void) 0)
   , q- J! q- a; X
5. #else
   
6.     #define assert(expr)        ((void) ((expr) || \
   
7.          (fprintf(stderr, "[%s(%d)] Assertion '%s' failed.\n", \
   
8.          __FILE__, __LINE__, #expr), abort(), 0)))
   
9. #endif

复制代码

# Q' F) S- D5 H/ u! y注意，expr1||expr2表达式作为单独语句出现时，等效于条件语句if(!(expr1))expr2。这样，assert宏就可扩展为一个表达式，而不是一条语句。逗号表达式expr2返回最后一个表达式的值(即0)，以符合||操作符的要求。
1 O+ j& x' F# i2 h使用断言时应注意以下几点：

• 断言用于检测理论上绝不应该出现的情况，如入参指针为空、除数为0等。
  

对比以下两种情况：

1. 
   9 S  l+ l1 z3 J5 ]$ v
2. char *Strcpy(char *pszDst, const char *pszSrc)
   & M: X0 [" k& t7 u  D. V& O6 p
3. {
   7 z. @1 u6 V- g5 V% M
4.     char *pszDstOrig = pszDst;
   
5.     assert((pszDst != NULL) && (pszSrc != NULL));
   
6.     while((*pszDst++ = *pszSrc++) != '\0');
   
7.         return pszDstOrig;
   4 ]/ @+ R* O: H' J
8. }
   
9. FILE *OpenFile(const char *pszName, const char *pszMode)
   
10. {
    . Q5 S: F, C' \4 P& I
11.     FILE *pFile = fopen(pszName, pszMode);
    
12.     assert(pFile != NULL);
    
13.     if(NULL == pFile)
    
14.         return NULL;
    4 O4 C  {) Z/ M  y
15. 
    
16.     //...
    , u' k, H* B0 s. ]
17.     return pFile;
    
18. }

复制代码

% i# M1 X+ Q$ {! k* L6 \( fStrcpy()函数中断言使用正确，因为入参字符串指针不应为空。OpenFile()函数中则不能使用断言，因为用户可能需要检查某个文件是否存在，而这并非错误或异常。
2)assert是宏不是函数，在调试版本和非调试版本中行为不同。因此必须确保断言表达式的求值不会产生副作用，如修改变量和改变方法的返回值。不过，可根据这一副作用测试断言是否打开：

1. 
   
2. int main(void)
   
3. {
   - S! }) ~9 v0 z8 ?1 I) o
4.     int dwChg = 0;
   
5.     assert(dwChg = 1);
   # @" D2 A3 }5 l, L
6.     if(0 == dwChg)
   0 H" K; F4 k$ I; ~& y% V
7.         printf("Assertion should be enabled!\n");
   ( _/ E3 B2 e* u4 |  r; Z! J$ h$ u
8.     return 0;
   / Y/ ?! a# K' u0 q% M" A
9. }

复制代码

• 不应使用断言检查公共方法的参数(应使用参数校验代码)，但可用于检查传递给私有方法的参数。
• 可使用断言测试方法执行的前置条件和后置条件，以及执行前后的不变性。
• 断言条件不成立时，会调用abort()函数终止程序，应用程序没有机会做清理工作(如关闭文件和数据库)。
  7 [! v* Z* G* E' c

3.3 封装
为减少错误检查和处理代码的重复性，可对函数调用或错误输出进行封装。

• 封装具有错误返回值的函数
  

通常针对频繁调用的基础性系统函数，如内存和内核对象操作等。举例如下：
& X8 v7 D3 l1 g/ h; |' J4 n& ^5 p

1. 
   
2. pid_t Fork(void) //首字母大写，以区分系统函数fork()
   
3. {
   " g' S, W5 j% N1 I) b
4.     pid_t pid;
   3 N) y9 n/ |4 D
5.     if((pid = fork())<0)
   
6.     {
   ; j3 P0 D  e$ }
7.         fprintf(stderr, "Fork error: %s\n", strerror(errno));
   0 W8 ^; b8 C/ L1 b; ^6 i4 ]% U
8.         exit(0);
   
9.     }
   
10.     return pid;
    
11. }

复制代码

Fork()函数出错退出时依赖系统清理资源。若还需清理其他资源(如已创建的临时文件)，可增加一个负责清理的回调函数。注意，并非所有系统函数都可封装，应根据具体业务逻辑确定。

• 封装错误输出
    c8 f5 M* o1 z7 Z$ U

通常需要使用ISO C变长参数表特性。例如《Unix网络编程》中将输出至标准出错文件的代码封装如下：
+ m. T% k( F; A, Z3 _8 f$ g( m

1. 
   0 H9 r5 f) e: E! }
2. #include <stdarg.h>
   4 y$ f1 N9 @$ G7 {! V
3. #include <syslog.h>
   
4. #define HAVE_VSNPRINTF  1
   & {  k- ^- X  S: D5 h+ n
5. #define MAXLINE         4096  /* max text line length */
   
6. int daemon_proc;  /* set nonzero by daemon_init() */
   
7. static void err_doit(int errnoflag, int level, const char * fmt, va_list ap)
   9 h& a9 Q$ x" c7 w6 ^
8. {
   8 v/ D8 b% ]' Q" I
9.     int errno_save, n;
   
10.     char buf[MAXLINE + 1];
    
11. 
    
12.     errno_save = errno;    /* Value caller might want printed. */
    
13. #ifdef HAVE_VSNPRINTF
    - A9 A- h: j# e& K
14.     vsnprintf(buf, MAXLINE, fmt, ap);
    6 e9 o7 S. _3 n# V$ x0 p
15. #else
    ( f; a% H* G+ h. _
16.     vsprintf(buf, fmt, ap);    /* This is not safe */
    
17. #endif
    
18.     n = strlen(buf);
    2 m( O- d' `5 B2 [- t. t, j: _0 U% U
19.     if (errnoflag) {
    ' \- F$ L: d1 c5 x. x% \' f0 l8 {
20.         snprintf(buf + n, MAXLINE - n, ": %s", strerror(errno_save));
    
21.     }
    1 E: \6 E6 ~9 i; Y+ W4 ^
22.     strcat(buf, "\n");
    
23. 
    ) b3 b8 x/ U1 n& _
24.     if (daemon_proc) {
    
25.         syslog(level, buf);
    
26.     } else {
    ! `6 J5 b/ A: ~' i
27.         fflush(stdout);    /* In case stdout and stderr are the same */
    - n' W( M2 n7 D: B6 Y0 @/ S& T
28.         fputs(buf, stderr);
    
29.         fflush(stderr);
    1 H; a1 _, v! i4 c
30.     }
    
31. 
    % F  M! q$ y; \* t  w% z0 p3 \! d# B
32.     return;
    
33. }
    ( x9 Y3 U: m) ^) p
34. 
    
35. void err_ret(const char * fmt, ...)
    
36. {
    ' N' Z4 B. z. S5 E3 H
37.     va_list ap;
    7 X, ^# x/ T# p- i6 z: s+ E8 k
38. 
    
39.     va_start(ap, fmt);
    - k/ H4 _* i0 P8 R
40.     err_doit(1, LOG_INFO, fmt, ap);
    
41.     va_end(ap);
    # m* P; }- t, W7 W  U9 a
42. 
    / H. Q6 E# S8 A8 {! b" O
43.     return;
    0 L" y9 B6 q3 ]
44. }

复制代码

! Y# a" R" I% [: }3 e) e; I

学习了，感谢分享