一个典型的异常处理包含如下几个步骤:
(1)程序执行时发生错误;
(2)以一个异常对象(最简单的是一个整数)记录错误的原因及相关信息;
(3)程序检测到这个错误(读取异常对象);
(4)程序决定如何处理错误;
(5)进行错误处理,并在此后恢复/终止程序的执行。
C、C++、MFC及SEH在这几个步骤中表现出了不同的特点。本文将对这四种异常处理进行介绍,并对它们进行对比分析。本文例程的调试平台为Visual C++6.0,操作系统为Windows XP,所有程序均调试通过。
在进入正式的讲解之前,先说几句废话。许多的编程新手对异常处理视而不见,程序里很少考虑异常情况。一部分人甚至根本就不考虑,以为程序总是能以正确的途径运行。譬如我们有的程序设计者调用fopen打开一个文件后,立马就开始进行读写操作,根本就不考虑文件是否正常打开了。这种习惯一定要改掉,纵使你再不愿意!这是软件健壮性的需要!异常处理不是浪费时间!
1.C语言异常处理
1.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模式运行时弹出如图1所示的对话框。
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。程序的输出如图2:
![]() 图2 assert的输出 |
失败的断言也会弹出如图1所示的对话框,这是因为_assert()函数中也调用了abort()函数。
一定要记住的是assert本质上是一个宏,而不是一个函数,因而不能把带有副作用的表达式放入assert的"参数"中。
1.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的赋值语句。
1.4 其它
除了上述异常处理方式外,在C语言中还支持非局部跳转(使用setjmp和longjmp)、信号(使用signal、raise)、返回错误值或回传错误值给参数等方式进行一定能力的异常处理,但是其使用不如1.1~1.3节所介绍方式常用,我们不必过细研究。
从以上分析可知,C语言的异常处理是简单而不全面的。与C++的异常处理比起来,C语言异常处理相形见绌,它就像娘胎里的雏婴。
2.C++语言异常处理
2.1 C++异常处理语法
感谢C++语言的后期改造者们,他们在标准C++语言中专门集成了异常处理的相关语法(与之不同的是,所有的C 标准库异常体系都需要运行库的支持,它不是语言内核支持的)。当然,异常处理被加到程序设计语言中,也是程序语言发展和逐步完善的必然结果。我们看到,C++不是唯一集成异常处理的语言。
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()函数就会被调用,弹出如图1所示的对话框,程序被终止;
(4)可以在函数头后加throw([type-ID-list])给出异常规格,声明其能抛出什么类型的异常。type-ID-list是一个可选项,其中包括了一个或多个类型的名字,它们之间以逗号分隔。如果函数没有异常规格指定,则可以抛出任意类型的异常。
2.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 *what() const throw(); }; |
其中的一个重要函数为what(),它返回一个表示异常的字符串指针。下面我们从exception类派生一个自己的类:
#include <iostream> #include <exception> using namespace std; class myexception:public exception { public: myexception():exception("一个重载exception的例子") {} }; int main() { try { throw myexception(); } catch (exception &r) //捕获异常 { cout << "捕获到异常:" << r.what() << endl; } return 0; } |
程序运行,输出:
捕获到异常:一个重载exception的例子
一般的,我们直接以基类捕获异常,例如,本例中使用了
catch (exception &r) |
然后根据基类的多态性进行处理,这是因为基类中的what函数是虚函数。
在标准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()函数就不会被调用了,也不会输出图1所示对话框。
关于标准C++的异常处理,还包含一些比较复杂的技巧和内容,我们可以查阅《more effective C++》的条款9~条款15。
MFC中异常处理的语法和语义构建在标准C++异常处理语法和语义的基础之上,其解决方案为:
MFC异常处理 = MFC 异常处理类 + 宏
3.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 再次抛出最近一次捕获的异常。
3.2 MFC 异常处理类
MFC较好地将异常封装到CException类及其派生类中,自成体系,下表给出了MFC 提供的预定义异常:
异常类 | 含义 |
CMemoryException | 内存不足 |
CFileException | 文件异常 |
CArchiveException | 存档/序列化异常 |
CNotSupportedException | 响应对不支持服务的请求 |
CResourceException | Windows 资源分配异常 |
CDaoException | 数据库异常(DAO 类) |
CDBException | 数据库异常(ODBC 类) |
COleException | OLE 异常 |
COleDispatchException | 调度(自动化)异常 |
CUserException | 用消息框警告用户然后引发一般 CException 的异常 |
标准C++的异常处理可以处理任意类型的异常,而3.1节的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; } END_CATCH } |
在这个程序中,如果D盘根目录下不存在"1.TXT"这个文件,将抛出CFileException异常,而且错误原因成员变量m_cause被设置为fileNotFound,我们以CATCH( CFileException, e )就可以捕获到。错误原因被定义为CFileException中的枚举(enum),如下:
enum { none, generic, fileNotFound, badPath, tooManyOpenFiles, accessDenied, invalidFile, removeCurrentDir, directoryFull, badSeek, hardIO, sharingViolation, lockViolation, diskFull, endOfFile }; |
我们在使用MFC相关类时,MFC会自动抛出异常,当然我们也可以自行在程序中利用AfxThrowXXXException()抛出各种类型的异常,其中的XXX与前文的MFC异常类表对应。我们看AfxThrowFileException的例子:
#include <iostream.h> #include "afxwin.h" int main() { TRY { AfxThrowFileException(CFileException::fileNotFound); } CATCH( CFileException, e ) { if( e->m_cause == CFileException::fileNotFound ) cout << "ERROR: File not found/n" << endl; } END_CATCH } |
在此程序中,我们在TRY块自行利用MFC提供的全局函数AfxThrowFileException抛出了CFileException异常,其后在CATCH块抓住了这个异常。
MFC建议不再使用TRY、CATCH和THROW宏,而是直接使用标准C++的方式。
结构化异常处理(Structured Exception Handling,简称SEH)是微软针对Windows程序异常处理进行的扩展,在Visual C++中,它同时支持C和C++语言。SEH不宜与标准C++异常处理和MFC异常处理混用,对于C++程序,微软建议使用标准C++的异常处理。
为了支持SEH,Visual C++中定义了四个关键字(由于这些关键字是非标准关键字,其它编译器不一定支持),用以扩展C 和C++语言:
(1)__except
(2)__finally
(3)__leave
(4)__try
其基本语法为:
__try { ...//可能导致异常的被监控代码块 } __except(filter-expression) { ...//异常处理函数 } |
或:
__try { ... } __finally { ...//终止 } |
其执行的步骤如下:
(1)__try块被执行;
(2)如果__try块没有出现异常,则执行到__except块之后;否则,执行到__except块,根据filter-expression的值决定异常处理方法:
a. filter-expression的值为EXCEPTION_CONTINUE_EXECUTION (-1)
恢复异常,从发生异常处下面开始执行,异常处理函数本身不被执行;
b. filter-expression的值为EXCEPTION_CONTINUE_SEARCH (0)
异常不被识别,拒绝捕获异常,继续搜索下一个异常处理函数;
c. filter-expression的值为EXCEPTION_EXECUTE_HANDLER (1)
异常被识别,终止异常,从异常发生处开始退栈,一路上遇到的终止函数都被执行。
看看这个例子:
//例4-1 #include "stdio.h" void main() { int* p = NULL; // 定义一个空指针 puts("SEH begin"); __try { puts("in try"); __try { puts("in try"); *p = 0; // 引发一个内存访问异常 } __finally { puts("in finally"); } } __except(puts("in filter"), 1) { puts("in except"); } puts("SEH end"); } |
程序的输出为:
SEH begin in try //执行__try块 in try //执行嵌入的__try块 in filter //执行filter-expression,返回EXCEPTION_EXECUTE_HANDLER in finally //展开嵌入的__finally in except //执行对应的__except块 SEH end //处理完毕 |
如果我们把__except(puts("in filter"), 1)改为__except(puts("in filter"), 0),程序的输出将变为:
SEH begin in try //执行__try块 in try //执行嵌入的__try块 in filter //执行filter-expression,返回EXCEPTION_CONTINUE_SEARCH in finally //展开嵌入的__finally |
程序的执行也告崩溃,弹出如图3所示的对话框。
![]() 图3 不能被正确执行的SEH |
要想这个程序能正确地执行,我们可以在第一个__try块的外面再套一个__try块和一个接收filter-expression返回值为EXCEPTION_EXECUTE_HANDLER的__except块,程序改为:
//例4-2 #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会不断进入此断点。
5.各种异常处理的对比
下表给出了从各个方面对这本文所给出的Visual C++所支持的四种异常处理进行的对比:
异常处理 | 支持语言 | 是否标准 | 复杂度 | 推荐使用 |
C异常处理 | C语言 | 标准C | 简单 | 推荐 |
C++异常处理 | C++语言 | 标准C++ | 较简单 | 推荐 |
MFC异常处理 | C++语言 | 仅针对MFC程序 | 较简单 | 不推荐 |
SEH异常处理 | C和C++语言 | 仅针对Microsoft编译环境 | 较复杂 | 不推荐 |
本文所讲解的仅仅是Visual C++异常处理的初步知识,对于更深入的内容,还需要我们在不断的编程过程中去领悟和学习。
在程序设计过程中,我们不能嫌异常处理"麻烦",对可能的错误视而不见、不加考虑。因为避免了异常处理的"麻烦",将会给我们的程序带来更大的"麻烦"。而程序中包含必要的异常处理,也是对一位优秀程序员的基本要求。