异常处理

C++ 语言异常处理 
Visual C++ 提供了对 C 语言、  C++ 语言及 MFC 的支持，因而其涉及到的异常（ exception ）处理也包含了这三种类型，即 C 语言、 C++ 语言和 MFC 的异常处理。除此之外，微软对 C 和 C++ 的异常处理进行了扩展，提出了结构化异常处理（ SEH ）的概念，它支持 C 和 C++ （与之相比， MFC 异常处理仅支持 C++ ）。  

　　  一个典型的异常处理包含如下几个步骤：  
　　  （ 1 ）程序执行时发生 错误 ；  
　　  （ 2 ）以一个异常对象（最简单的是一个整数）记录 错误 的原因及相关信息；  
　　  （ 3 ）程序检测到这个 错误 （读取异常对象）；  
　　  （ 4 ）程序决定如何处理 错误 ；  
　　  （ 5 ）进行 错误 处理，并在此后恢复 / 终止程序的执行。  
　　  C 、 C++ 、 MFC 及 SEH 在这几个步骤中表现出了不同的特点。

C 语言异常处理  

　　  1  异常终止  
　　  标准 C 库提供了 abort() 和 exit() 两个函数，它们可以强行终止程序的运行，其声明处于 <stdlib.h> 头文件中。这两个函数本身不能检测异常，但在 C 程序发生异常后经常使用这两个函数进行程序终止。下面的这个例子描述了 exit() 的行为：  

#include <stdio.h> 
#include <stdlib.h> 
int main(void) 
{ 
　  exit(EXIT_SUCCESS); 
　  printf(" 程序不会执行到这里 /n"); 
　  return 0; 
}  

　　  在这个例子中， main 函数一开始就执行了 exit 函数（此函数原型为 void exit(int) ），因此，程序不会输出 " 程序不会执行到这里 " 。程序中的 exit(EXIT_SUCCESS) 表示程序正常结束，与之对应的 exit(EXIT_FAILURE) 表示程序执行 错误 ，只能强行终止。 EXIT_SUCCESS 、 EXIT_FAILURE 分别定义为 0 和 1 。  

　　  对于 exit 函数，我们可以利用 atexit 函数为 exit 事件 " 挂接 " 另外的函数，这种 " 挂接 " 有点类似 Windows 编程中的 " 钩子 " （ Hook ）。譬如：  

#include <stdio.h> 
#include <stdlib.h> 
static void atExitFunc(void) 
{ 
　  printf("atexit 挂接的函数 /n"); 
} 
int main(void) 
{ 
　  atexit(atExitFunc); 
　  exit(EXIT_SUCCESS); 
　  printf(" 程序不会执行到这里 /n"); 
　  return 0; 
}  

　　  程序输出 "atexit 挂接的函数 " 后即终止。来看下面的程序，我们不调用 exit 函数，看看 atexit 挂接的函数会否执行：  

#include <stdio.h> 
#include <stdlib.h> 
static void atExitFunc(void) 
{ 
　  printf("atexit 挂接的函数 /n"); 
} 
int main(void) 
{ 
　  atexit(atExitFunc); 
　  //exit(EXIT_SUCCESS); 
　  printf(" 不调用 exit 函数 /n"); 
　  return 0; 
}  

　　  程序输出：  
　　  不调用 exit 函数  
　　  atexit 挂接的函数  

　　  这说明，即便是我们不调用 exit 函数，当程序本身退出时， atexit 挂接的函数仍然会被执行。  
　　  atexit 可以被多次执行，并挂接多个函数，这些函数的执行顺序为后挂接的先执行，例如：  

#include <stdio.h> 
#include <stdlib.h> 

static void atExitFunc1(void) 
{ 
　  printf("atexit 挂接的函数 1/n"); 
} 

static void atExitFunc2(void) 
{ 
　  printf("atexit 挂接的函数 2/n"); 
} 

static void atExitFunc3(void) 
{ 
　  printf("atexit 挂接的函数 3/n"); 
} 

int main(void) 
{ 
　  atexit(atExitFunc1); 
　  atexit(atExitFunc2); 
　  atexit(atExitFunc3); 
　  return 0; 
}  

　　  输出的结果是：  
　　　  atexit 挂接的函数 3 
　　　  atexit 挂接的函数 2 
　　　  atexit 挂接的函数 1 

　　  在 Visual C++ 中，如果以 abort 函数（此函数不带参数，原型为 void abort(void) ）终止程序，则会在 debug 模式运行时弹出对话框。 

2  断言 (assert) 
　　  assert 宏在 C 语言程序的调试中发挥着重要的作用，它用于检测不会发生的情况，表明一旦发生了这样的情况，程序就实际上执行错误了，例如 strcpy 函数：  
char *strcpy(char *strDest, const char *strSrc) 
{ 
　  char * address = strDest; 
　  assert((strDest != NULL) && (strSrc != NULL)); 
　  while ((*strDest++ = *strSrc++) != '/0') 
　　  ; 
　  return address; 
}  
　　  其中包含断言 assert( (strDest != NULL) && (strSrc != NULL) ) ，它的意思是源和目的字符串的地址都不能为空，一旦为空，程序实际上就执行错误了，会引发一个 abort 。  

　　  assert 宏的定义为：  
#ifdef NDEBUG 
#define assert(exp) ((void)0) 
#else 
#ifdef __cplusplus 
extern "C" 
{ 
　  #endif 

　  _CRTIMP void __cdecl _assert(void *, void *, unsigned); 
　  #ifdef __cplusplus 
} 
#endif 
#define assert(exp) (void)( (exp) || (_assert(#exp, __FILE__, __LINE__), 0) ) 
#endif /* NDEBUG */  
　　  如果程序不在 debug 模式下， assert 宏实际上什么都不做；而在 debug 模式下，实际上是对 _assert()  函数的调用，此函数将输出发生错误的文件名、代码行、条件表达式。例如下列程序：  
#include <stdio.h> 
#include <stdlib.h> 
#include <assert.h> 
char * myStrcpy( char *strDest, const char *strSrc ) 
{ 
　  char *address = strDest; 
　  assert( (strDest != NULL) && (strSrc != NULL) ); 
　  while( (*strDest++ = *strSrc++) != '/0' ); 
　　  return address; 
} 
int main(void) 
{ 
　  myStrcpy(NULL,NULL); 
　  return 0; 
}  

　　  在此程序中，为了避免我们的 strcpy 与 C 库中的 strcpy 重名，将其改为 myStrcpy 。

失败的断言也会弹出对话框，这是因为 _assert() 函数中也调用了 abort() 函数。  
　　  assert 本质上是一个宏，而不是一个函数，因而不能把带有副作用的表达式放入 assert 的 " 参数 " 中。  

　　 3 errno 
　　  errno 在 C 程序中是一个全局变量，这个变量由 C 运行时库函数设置，用户程序需要在程序发生异常时检测之。 C 运行库中主要在 math.h 和 stdio.h 头文件声明的函数中使用了 errno ，前者用于检测数学运算的合法性，后者用于检测 I/O 操作中（主要是文件）的错误，例如：  
#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; 
}  
　　  在此程序中，如果文件打开失败（ fopen 返回 NULL ），证明发生了异常。我们读取 error 可以获知错误的原因，如果 D 盘根目录下不存在 "1.txt" 文件，将输出 2 ，表示文件不存在；在文件存在并正确打开的情况下，将执行到 else 语句，输出 0 ，证明 errno 没有被设置。  

　　  Visual C++ 提供了两种版本的 C 运行时库。 - 个版本供单线程应用程序调用，另一个版本供多线程应用程序调用。多线程运行时库与单线程运行时库的一个重大差别就是对于类似 errno 的全局变量，每个线程单独设置了一个。因此，对于多线程的程序，我们应该使用多线程 C 运行时库，才能获得正确的 error 值。  
　　  另外，在使用 errno 之前，我们最好将其设置为 0 ，即执行 errno = 0 的赋值语句。  

　　  4  其它  
　　  除了上述异常处理方式外，在 C 语言中还支持非局部跳转（使用 setjmp 和 longjmp ）、信号（使用  signal  、 raise ）、返回错误值或回传错误值给参数等方式进行一定能力的异常处理。  
　　  从以上分析可知， C 语言的异常处理是简单而不全面的。与 C++ 的异常处理比起来， C 语言异常处理相形见绌。 

 C++ 异常处理语法  
  标准 C++ 语言中专门集成了异常处理的相关语法（与之不同的是，所有的 C  标准库异常体系都需要运行库的支持，它不是语言内核支持的）。当然，异常处理被加到程序设计语言中，也是程序语言发展和逐步完善的必然结果。 C++ 不是唯一集成异常处理的语言。  

 1  C++ 的异常处理结构为：  
try 
{ 
// 可能引发异常的代码  
} 
catch(type_1 e) 
{ 
// type_1 类型异常处理  
} 
catch(type_2 e) 
{ 
// type_2 类型异常处理  
} 
catch (...)// 会捕获所有未被捕获的异常，必须最后出现  
{ 
}  

　　  而异常的抛出方式为使用 throw(type e) ， try 、 catch 和 throw 都是 C++ 为处理异常而添加的关键字。举例如下：  

#include <stdio.h> 
// 定义 Point 结构体（类）  
typedef struct tagPoint 
{ 
　  int x; 
　  int y; 
} Point; 
// 扔出 int 异常的函数  
static void f(int n) 
{ 
　  throw 1; 
} 

// 扔出 Point 异常的函数  
static void f(Point point) 
{ 
　  Point p; 
　  p.x = 0; 
　  p.y = 0; 
　  throw p; 
} 

int main() 
{ 
　  Point point; 
　  point.x = 0; 
　  point.y = 0; 

　  try 
　  { 
　　  f(point); // 抛出 Point 异常  
　　  f(1); // 抛出 int 异常  
　  } 
　  catch (int e) 
　  { 
　　  printf(" 捕获到 int 异常： %d/n", e); 
　  } 
　  catch (Point e) 
　  { 
　　  printf(" 捕获到 Point 异常 :(%d,%d)/n", e.x, e.y); 
　  } 

　  return 0; 
}  

　　  函数 f 定义了两个版本： f(int) 和 f(Point) ，分别抛出 int 和 Point 异常。当 main 函数的 try{ … } 中调用 f(point) 时和 f(1) 时，分别输出：  

　　  捕获到 Point 异常 :(0,0) 
　　  捕获到 int 异常： 1 

　　  在 C++ 中， throw 抛出异常的特点有：  
　　  （ 1 ）可以抛出基本数据类型异常，如 int 和 char 等；  
　　  （ 2 ）可以抛出复杂数据类型异常，如结构体（在 C++ 中结构体也是类）和类；  
　　  （ 3 ） C++ 的异常处理必须由调用者主动检查。一旦抛出异常，而程序不捕获的话，那么 abort() 函数就会被调用，程序被终止；  
　　  （ 4 ）可以在函数头后加 throw([type-ID-list]) 给出异常规格，声明其能抛出什么类型的异常。 type-ID-list 是一个可选项，其中包括了一个或多个类型的名字，它们之间以逗号分隔。如果函数没有异常规格指定，则可以抛出任意类型的异常。  

　　  2  标准异常  

　　  下面给出了 C++ 提供的一些标准异常：  
namespace std 
{ 
　  //exception 派生  
　  class logic_error; // 逻辑错误 , 在程序运行前可以检测出来  

　  //logic_error 派生  
　  class domain_error; // 违反了前置条件  
　  class invalid_argument; // 指出函数的一个无效参数  
　  class length_error; // 指出有一个超过类型 size_t 的最大可表现值长度的对象的企图  
　  class out_of_range; // 参数越界  
　  class bad_cast; // 在运行时类型识别中有一个无效的 dynamic_cast 表达式  
　  class bad_typeid; // 报告在表达试 typeid(*p) 中有一个空指针 p 

　  //exception 派生  
　  class runtime_error; // 运行时错误 , 仅在程序运行中检测到  

　  //runtime_error 派生  
　  class range_error; // 违反后置条件  
　  class overflow_error; // 报告一个算术溢出  
　  class bad_alloc; // 存储分配错误  
}  

　　  请注意观察上述类的层次结构，可以看出，标准异常都派生自一个公共的基类 exception 。基类包含必要的多态性函数提供异常描述，可以被重载。下面是 exception 类的原型：  

class exception 
{ 
　  public: 
　　  exception() throw(); 
　　  exception(const exception& rhs) throw(); 
　　  exception& operator=(const exception& rhs) throw(); 
　　  virtual ~exception() throw(); 
　　  virtual const char *wh

}

3 异常处理函数  
　　  在标准 C++ 中，还定义了数个异常处理的相关函数和类型（包含在头文件 <exception> 中）：  
namespace std 
{ 
　  //EH 类型  
　  class bad_exception; 
　  class exception; 

　  typedef void (*terminate_handler)(); 
　  typedef void (*unexpected_handler)(); 

　  //  函数  
　  terminate_handler set_terminate(terminate_handler) throw(); 
　  unexpected_handler set_unexpected(unexpected_handler) throw(); 

　  void terminate(); 
　  void unexpected(); 

　  bool uncaught_exception(); 
}  

　　  其中的 terminate 相关函数与未被捕获的异常有关，如果一种异常没有被指定 catch 模块，则将导致 terminate() 函数被调用， terminate() 函数中会调用 ahort() 函数来终止程序。可以通过 set_terminate(terminate_handler) 函数为 terminate() 专门指定要调用的函数，例如：  

#include <cstdio> 
#include <exception> 
using namespace std; 
// 定义 Point 结构体（类）  
typedef struct tagPoint 
{ 
　  int x; 
　  int y; 
} Point; 
// 扔出 Point 异常的函数  
static void f() 
{ 
　  Point p; 
　  p.x = 0; 
　  p.y = 0; 
　  throw p; 
} 
//set_terminate 将指定的函数  
void terminateFunc() 
{ 
　  printf("set_terminate 指定的函数 /n"); 
} 

int main() 
{ 
　  set_terminate(terminateFunc); 
　  try 
　  { 
　　  f(); // 抛出 Point 异常  
　  } 
　  catch (int) // 捕获 int 异常  
　  { 
　　  printf(" 捕获到 int 异常 "); 
　  } 
　  //Point 将不能被捕获到 , 引发 terminateFunc 函数被执行  

　  return 0; 
}  

　　  这个程序将在控制台上输出  "set_terminate 指定的函数 "  字符串，因为 Point 类型的异常没有被捕获到。当然，它也会弹出图 1 所示对话框（因为调用了 abort() 函数）。  

　　  上述给出的仅仅是一个 set_terminate 指定函数的例子。在实际工程中，往往使用 set_terminate 指定的函数进行一些清除性的工作，其后再调用 exit(int) 函数终止程序。这样， abort() 函数就不会被调用了，也不会输出对话框。  

MFC 异常处理  
　　  MFC 中异常处理的语法和语义构建在标准 C++ 异常处理语法和语义的基础之上，其解决方案为：  
　　  MFC 异常处理  = MFC  异常处理类  ＋  宏  
 1 宏  
　　  MFC 定义了 TRY 、 CATCH （及 AND_CATCH 、 END_CATCH ）和 THROW （及 THROW_LAST ）等用于异常处理的宏，其本质上也是标准 C++ 的 try 、 catch 和 throw 的进一步强化，由这些宏的定义可知：  
#ifndef _AFX_OLD_EXCEPTIONS 

#define TRY { AFX_EXCEPTION_LINK _afxExceptionLink; try { 

#define CATCH(class, e) } catch (class* e) / 
{ ASSERT(e->IsKindOf(RUNTIME_CLASS(class))); / 
_afxExceptionLink.m_pException = e; 

#define AND_CATCH(class, e) } catch (class* e) / 
{ ASSERT(e->IsKindOf(RUNTIME_CLASS(class))); / 
_afxExceptionLink.m_pException = e; 

#define END_CATCH } } 

#define THROW(e) throw e 
#define THROW_LAST() (AfxThrowLastCleanup(), throw) 

// Advanced macros for smaller code 
#define CATCH_ALL(e) } catch (CException* e) / 
{ { ASSERT(e->IsKindOf(RUNTIME_CLASS(CException))); / 
_afxExceptionLink.m_pException = e; 

#define AND_CATCH_ALL(e) } catch (CException* e) / 
{ { ASSERT(e->IsKindOf(RUNTIME_CLASS(CException))); / 
_afxExceptionLink.m_pException = e; 

#define END_CATCH_ALL } } } 

#define END_TRY } catch (CException* e) / 
{ ASSERT(e->IsKindOf(RUNTIME_CLASS(CException))); / 
_afxExceptionLink.m_pException = e; } }  
　　  这些宏在使用语法上，有如下特点：  
　　  （ 1 ）用 TRY  块包含可能产生异常的代码；  
　　  （ 2 ）用 CATCH 块检测并处理异常。要注意的是， CATCH 块捕获到的不是异常对象，而是指向异常对象的指针。此外， MFC 靠动态类型来辨别异常对象；  
　　  （ 3 ）可以在一个 TRY  块上捆绑多个异常处理捕获块，第一次捕获使用宏 CATCH ，以后的使用 AND_CATCH ，而 END_CATCH 则用来结束异常捕获队列；  
　　  （ 4 ）在异常处理程序内部，可以用 THROW_LAST  再次抛出最近一次捕获的异常。 

 
　 2 MFC  异常处理类  
　　  MFC 较好地将异常封装到 CException 类及其派生类中，自成体系，下表给出了 MFC  提供的预定义异常：  
异常类    含义   
CMemoryException   内存不足   
CFileException   文件异常   
CArchiveException   存档 / 序列化异常   
CNotSupportedException   响应对不支持服务的请求   
CResourceException  Windows  资源分配异常   
CDaoException   数据库异常（ DAO  类）   
CDBException   数据库异常（ ODBC  类）   
COleException  OLE  异常   
COleDispatchException   调度（自动化）异常   
CUserException   用消息框警告用户然后引发一般  CException  的异常   

　　  标准 C++ 的异常处理可以处理任意类型的异常，而上节的 MFC  宏则只能处理 CException  的派生类型，下面我们看一个 CFileException 的使用例子：  

#include <iostream.h> 
#include "afxwin.h" 

int main() 
{ 
　  TRY 
　  { 
　　  CFile f( "d://1.txt", CFile::modeWrite ); 
　  } 
　  CATCH( CFileException, e ) 
　  { 
　　  if( e->m_cause == CFileException::fileNotFound ) 
　　　  cout << "ERROR: File not found/n" << endl; 

}

}

要想这个程序能正确地执行，我们可以在第一个 __try 块的外面再套一个 __try 块和一个接收 filter-expression 返回值为 EXCEPTION_EXECUTE_HANDLER 的 __except 块，程序改为：  

#include "stdio.h" 

void main() 
{ 
　  int* p = NULL; //  定义一个空指针  
　  puts("SEH begin"); 
　  __try 
　  { 
　　  __try 
　　  { 
　　　  puts("in try"); 
　　　  __try 
　　　  { 
　　　　  puts("in try"); 
　　　　  *p = 0; //  引发一个内存访问异常  
　　　  } 
　　　  __finally 
　　　  { 
　　　　  puts("in finally"); 
　　　  } 
　　  } 
　　  __except(puts("in filter"), 0) 
　　  { 
　　　  puts("in except"); 
　　  } 
　  } 
　  __except(puts("in filter"), 1) 
　  { 
　　  puts("in except"); 
　  } 
　  puts("SEH end"); 
}  

　　  程序输出： 

SEH begin 

in try // 执行 __try 块  
in try // 执行嵌入的 __try 块  
in filter1 // 执行 filter-expression ，返回 EXCEPTION_CONTINUE_SEARCH 
in filter2 // 执行 filter-expression ，返回 EXCEPTION_EXECUTE_HANDLER 
in finally // 展开嵌入的 __finally 
in except2 // 执行对应的 __except 块  
SEH end // 处理完毕   
　　  由此可以看出，因为第一个 __except 的 filter-expression 返回 EXCEPTION_CONTINUE_SEARCH  的原因， "in except1" 没有被输出。程序之所以没有崩溃，是因为最终碰到了接收 EXCEPTION_EXECUTE_HANDLER 的第 2 个 __except 。  

　　  SEH 使用复杂的地方在于较难控制异常处理的流动方向，弄不好程序就 " 挂 " 了。如果把例 4-1 中的 __except(puts("in filter"), 1) 改为 __except(puts("in filter"), -1) ，程序会进入一个死循环，输出：  

SEH begin 
in try // 执行 __try 块  
in try // 执行嵌入的 __try 块  
in filter // 执行 filter-expression ，返回 EXCEPTION_CONTINUE_EXECUTION 
in filter 
in filter 
in filter 
in filter 
… // 疯狂输出 "in filter"  
　　  最后疯狂地输出 "in filter" ，我们把断点设置在 __except(puts("in filter"), -1) 语句之前，按 F5 会不断进入此断点。 

  各种异常处理的对比  
　　  下表给出了从各个方面对这本文所给出的 Visual C++ 所支持的四种异常处理进行的对比：  
     异常处理    支持语言    是否标准    复杂度    推荐使用   
       C 异常处理   C 语言    标准 C   简单    推荐   
       C++ 异常处理   C++ 语言    标准 C++   较简单    推荐   
       MFC 异常处理   C++ 语言    仅针对 MFC 程序    较简单    不推荐   
       SEH 异常处理   C 和 C++ 语言    仅针对 Microsoft 编译环境    较复杂    不推荐