阿愚谈Exception.doc

阿愚谈Exception
前言
主人公介绍
　　阿愚，曾经是一位小小程序员，现在仍是一位小小程序员，将来也还是一位小小程序员。读程序、写程序一直就是他的最爱，这过程给他带来许许多多的快乐，虽然期间也有过一些迷茫，但每次冲过迷雾，重见阳光的喜悦总是他对程序人生的更加执著追求。雨过天晴的空气才是最清新的。
　　异常处理的编程方法，程序员都很熟悉的一个东东，她和面向对象的方法是软件程序设计发展史上其中最重要的两项革新技术。 现代程序设计语言拥有的一个重要的特性就是能较好地支持异常的处理(Exception Handling)。她就像一位美丽而优雅的公主，帮助程序员写出来的代码总是那样的整齐美观、层次清晰;同时它好像还是一位贤惠能干的贤内助，总能帮你 料理好由于考虑不全所留下的多多少少的意外事件，她在背后默默的支持你的一切，使你写出来的作品是那样的高效、安全和完美。瞧!它深深地打动了我们我们的主人公阿愚，并续上了一段美丽的编程爱情故事。
　　内容的组织及编排
　　相遇篇
　　《第1集 初次与异常处理编程相邂逅》
　　《第2集 C++中异常处理的游戏规则》
　　《第3集 C++中catch(…)如何使用》
　　《第4集 C++的异常处理和面向对象的紧密关系》
　　《第5集 C++的异常rethrow》
　　相知篇
　　《第6集 对象的成员函数中抛出的异常》
　　《第7集 构造函数中抛出的异常》
　　《第8集 析构函数中抛出的异常》
　　《第9集 C++的异常对象如何传送》
　　《第10集 C++的异常对象按传值的方式被传递》
　　《第11集 C++的异常对象按引用方式被传递》
　　《第12集 C++的异常对象按指针方式被传递》
　　《第13集 C++异常对象三种方式传递的综合比较》
　　《第14集 再探C++中异常的rethrow》
　　《第15集 C语言中的异常处理机制》
　　《第16集 C语言中一种更优雅的异常处理机制》
　　《第17集 全面了解setjmp与longjmp的使用》
　　《第18集 玩转setjmp与longjmp》
　　《第19集 setjmp与longjmp机制，很难与C++和睦相处》
　　《第20集 C++中如何兼容并支持C语言中提供的异常处理机制》
　　《第21集 Windows系列操作系统平台中的提供的异常处理机制》
　　《第22集 更进一步认识SEH》
　　《第23集 SEH的强大功能之一》
　　《第24集 SEH的强大功能之二》
　　《第25集 SEH的综合》
　　《第26集 SEH可以在C++程序中使用》
　　《第27集 SEH与C++异常模型的混合使用》
　　《第28集 Java中的异常处理模型》
　　《第29集 Unix操作系统提供中的异常处理机制》
　　相爱篇
　　《让异常成为函数接口的一部分》
　　《异常能够优雅地跨越组件》
　　《C++标准库中的异常分类模型》
　　《MFC类库中的异常分类模型》
　　《JDK平台中的异常分类模型》
　　爱的秘密
　　《实现》
　　爱的结晶
　　《对现有模型的一些完善与改进》
第1集 初次与异常处理编程相邂逅
　作者：王胜祥　来源：希赛网　2008年1月3日　　进入社区
　　和其它很多程序员一样，本书的主人公阿愚也是在初学C++时，在C++的sample代码中与异常处理的编程方法初次邂逅的，如下：
　　// Normal program statements
　　...
　　try
　　{
　　// Execute some code that might throw an exception.
　　}
　　catch( CException* e )
　　{
　　// Handle the exception here.
　　// "e" contains information about the exception.
　　e->Delete();
　　}
　　// Other normal program statements
　　瞧瞧，代码看上去显得那么整齐、干净，try block和catch block遥相呼应，多有对称美呀!因此主人公初次见面后就一见钟情了。
　　为什么要选用异常处理的编程方法?
　　当然更为重要的是，C++中引入的异常处理的编程机制提供给程序员一种全新的、更好的编程方法和思想。在C++中明确提出trycatch异常处理编程方法的框架之前的年代，程序员是怎样编写程序的，如下：
　　void main(int argc, char* argv[])
　　{
　　if (Call_Func1(in, param out)
　　{
　　// 函数调用成功，我们正常的处理
　　if (Call_Func2(in, param out)
　　{
　　// 函数调用成功，我们正常的处理
　　while(condition)
　　{
　　//do other job
　　if (has error)
　　{
　　// 函数调用失败，表明程序执行过程中出现一些错误，
　　// 因此必须处理错误
　　process_error();
　　exit();
　　}
　　//do other job
　　}
　　}
　　else
　　{
　　// 函数调用失败，表明程序执行过程中出现一些错误，
　　// 因此必须处理错误
　　process_error();
　　exit();
　　}
　　}
　　else
　　{
　　// 函数调用失败，同样是错误处理
　　process_error();
　　exit();
　　}
　　}
　　因为程序的执行过程中总会遇到许多可预知或不可预知的错误事件，例如说，由于内存资源有 限导致需要分配的内存失败了;或某个目录下本应存在的一个文件找不着了;或说不小心被零除了、内存越界了、数组越界了等等。这些错误事件存在非常大的隐 患，因此程序员总需要在程序中不断加入if语句，来判断是否有异常出现，如果有，就必须要及时处理，否则可能带来意想不到的，甚至是灾难性的后果。这样一 来，程序可读性差了很多，总是有许多与真正工作无关的代码，而且也给程序员增加了极大的工作负担，多数类似的处理错误的代码模块就像满山的牛屎一样遍地都 是(程序员不大多是“牛”人吗?所以。。。哈哈)。
　　但C++中的异常处理的机制彻底改变了这种面貌，它使真正的计算处理和错误处理分开来，让程序员不再被这些琐碎的事情所烦扰，能关注于真正的计算处理工作。同时代码的可读性也好了。因此我们有理由选择异常处理的编程方法。具体原因如下：
　　1、 把错误处理和真正的工作分开来;
　　2、 代码更易组织，更清晰，复杂的工作任务更容易实现;
　　3、 毫无疑问，更安全了，不至于由于一些小的疏忽而使程序意外崩溃了;
　　4、 由于C++中的try catch可以分层嵌套，所以它提供了一种方法使得程序的控制流可以安全的跳转到上层(或者上上层)的错误处理模块中去。(不同于return语句，异常处理的控制流是可以安全地跨越一个或多个函数 )。
　　5、 还有一个重要的原因就是，由于目前需要开发的软件产品总是变得越来越复杂、越来越庞大，如果系统中没有一个可靠的异常处理模型，那必定是一件十分糟糕的局面。
　　相信绝大多数程序员都知道C++中的异常处理的编程方法，可还是有很多人已习惯原来单纯的面向过程的代码组织方式，不太习惯或较少使用 trycatch异常处理。为了使您编写的代码更安全;为了使您编写的代码让他人更易阅读，主人公阿愚强烈建议在您书写的代码中尽可能多用异常处理机制， 少一些不必要的if判断语句。
　　下一集详细介绍C++中的异常处理的语法。
第2集 C++中异常处理的游戏规则
　作者：王胜祥　来源：希赛网　2008年1月3日　　进入社区
　　如果您喜欢玩一款游戏，您必须先要很好理解这款游戏的规则。同样主人公阿愚喜欢上C++中异常处理后，当然也首先关注它的游戏规则，这就是C++中异常处理的语法。
　　关键字
　　1、 try
　　2、 catch
　　3、 throw
　　其中关键字try表示定义一个受到监控、受到保护的程序代码块;关键字catch与try遥相呼应，定义当try block(受监控的程序块)出现异常时，错误处理的程序模块，并且每个catch block都带一个参数(类似于函数定义时的数那样)，这个参数的数据类型用于异常对象的数据类型进行匹配;而throw则是检测到一个异常错误发生后向 外抛出一个异常事件，通知对应的catch程序块执行对应的错误处理。
　　语法
　　1、还是给一个例子吧!如下：
　　int main()
　　{
　　cout << "In main." << endl;
　　//定义一个try block，它是用一对花括号{}所括起来的块作用域的代码块
　　try
　　{
　　cout << "在 try block 中, 准备抛出一个异常." << endl;
　　//这里抛出一个异常(其中异常对象的数据类型是int，值为1)
　　//由于在try block中的代码是受到监控保护的，所以抛出异常后，程序的
　　//控制流便转到随后的catch block中
　　throw 1;
　　cout << "在 try block 中, 由于前面抛出了一个异常，因此这里的代码是不会得以执行到的" << endl;
　　}
　　//这里必须相对应地，至少定义一个catch block，同样它也是用花括号括起来的
　　catch( int& value )
　　{
　　cout << "在 catch block 中, 处理异常错误。异常对象value的值为："<< value << endl;
　　}
　　cout << "Back in main. Execution resumes here." << endl;
　　return 0;
　　}
　　2、语法很简单吧!的确如此。另外一个try block可以有多个对应的catch block，可为什么要多个catch block呢?这是因为每个catch block匹配一种类型的异常错误对象的处理，多个catch block呢就可以针对不同的异常错误类型分别处理。毕竟异常错误也是分级别的呀!有致命的、有一般的、有警告的，甚至还有的只是事件通知。例子如下：
　　int main()
　　{
　　try
　　{
　　cout << "在 try block 中, 准备抛出一个int数据类型的异常." << endl;
　　throw 1;
　　cout << "在 try block 中, 准备抛出一个double数据类型的异常." << endl;
　　throw 0.5;
　　}
　　catch( int& value )
　　{
　　cout << "在 catch block 中, int数据类型处理异常错误。”<< endl;
　　}
　　catch( double& d_value )
　　{
　　cout << "在 catch block 中, double数据类型处理异常错误。”<< endl;
　　}
　　return 0;
　　}
　　3、一个函数中可以有多个trycatch结构块，例子如下：
　　int main()
　　{
　　try
　　{
　　cout << "在 try block 中, 准备抛出一个int数据类型的异常." << endl;
　　throw 1;
　　}
　　catch( int& value )
　　{
　　cout << "在 catch block 中, int数据类型处理异常错误。”<< endl;
　　}
　　//这里是二个trycatch结构块，当然也可以有第三、第四个，甚至更多
　　try
　　{
　　cout << "在 try block 中, 准备抛出一个double数据类型的异常." << endl;
　　throw 0.5;
　　}
　　catch( double& d_value )
　　{
　　cout << "在 catch block 中, double数据类型处理异常错误。”<< endl;
　　}
　　return 0;
　　}
　　4、上面提到一个try block可以有多个对应的catch block，这样便于不同的异常错误分类处理，其实这只是异常错误分类处理的方法之一(暂且把它叫做横向展开的吧!)。另外还有一种就是纵向的，也即是分 层的、trycatch块是可以嵌套的，当在低层的trycatch结构块中不能匹配到相同类型的catch block时，它就会到上层的trycatch块中去寻找匹配到正确的catch block异常处理模块。例程如下：
　　int main()
　　{
　　try
　　{
　　//这里是嵌套的trycatch结构块
　　try
　　{
　　cout << "在 try block 中, 准备抛出一个int数据类型的异常." << endl;
　　throw 1;
　　}
　　catch( int& value )
　　{
　　cout << "在 catch block 中, int数据类型处理异常错误。”<< endl;
　　}
　　cout << "在 try block 中, 准备抛出一个double数据类型的异常." << endl;
　　throw 0.5;
　　}
　　catch( double& d_value )
　　{
　　cout << "在 catch block 中, double数据类型处理异常错误。”<< endl;
　　}
　　return 0;
　　}
　　5、讲到是trycatch块是可以嵌套分层的，并且通过异常对象的数据类型来进行匹配，以找到正确的catch block异常错误处理代码。这里就不得不详细叙述一下通过异常对象的数据类型来进行匹配找到正确的catch block的过程。
　　(1) 首先在抛出异常的trycatch块中查找catch block，按顺序先是与第一个catch block块匹配，如果抛出的异常对象的数据类型与catch block中传入的异常对象的临时变量(就是catch语句后面参数)的数据类型完全相同，或是它的子类型对象，则匹配成功，进入到catch block中执行;否则到二步;
　　(2) 如果有二个或更多的catch block，则继续查找匹配第二个、第三个，乃至最后一个catch block，如匹配成功，则进入到对应的catch block中执行;否则到三步;
　　(3) 返回到上一级的trycatch块中，按规则继续查找对应的catch block。如果找到，进入到对应的catch block中执行;否则到四步;
　　(4) 再到上上级的trycatch块中，如此不断递归，直到匹配到顶级的trycatch块中的最后一个catch block，如果找到，进入到对应的catch block中执行;否则程序将会执行terminate()退出。
　　另外分层嵌套的trycatch块是可以跨越函数作用域的，例程如下：
　　void Func() throw()
　　{
　　//这里实际上也是嵌套在里层的trycatch结构块
　　try
　　{
　　cout << "在 try block 中, 准备抛出一个int数据类型的异常." << endl;
　　//由于这个trycatch块中不能找到匹配的catch block，所以
　　//它会继续查找到调用这个函数的上层函数的trycatch块。
　　throw 1;
　　}
　　catch( float& value )
　　{
　　cout << "在 catch block 中, int数据类型处理异常错误。”<< endl;
　　}
　　}
　　int main()
　　{
　　try
　　{
　　Func();
　　cout << "在 try block 中, 准备抛出一个double数据类型的异常." << endl;
　　throw 0.5;
　　}
　　catch( double& d_value )
　　{
　　cout << "在 catch block 中, double数据类型处理异常错误。”<< endl;
　　}
　　catch( int& value )
　　{
　　//这个例子中，Func()函数中抛出的异常会在此被处理
　　cout << "在 catch block 中, int数据类型处理异常错误。”<< endl;
　　}
　　return 0;
　　}
　　6、刚才提到，嵌套的trycatch块是可以跨越函数作用域的，其实这里面还有另外一层涵义，就是抛出异常对象的函数中并不一定必须存在 trycatch块，它可以是调用这个函数的上层函数中存在trycatch块，这样这个函数的代码也同样是受保护、受监控的代码;当然即便是上层调用函 数不存在trycatch块，也只是不能找到处理这类异常对象错误处理的catch block而已，例程如下：
　　void Func() throw()
　　{
　　//这里实际上也是嵌套在里层的trycatch结构块
　　//由于这个函数中是没有trycatch块的，所以它会查找到调用这个函数的上
　　//层函数的trycatch块中。
　　throw 1;
　　}
　　int main()
　　{
　　try
　　{
　　//调用函数，注意这个函数里面抛出一个异常对象
　　Func();
　　cout << "在 try block 中, 准备抛出一个double数据类型的异常." << endl;
　　throw 0.5;
　　}
　　catch( double& d_value )
　　{
　　cout << "在 catch block 中, double数据类型处理异常错误。”<< endl;
　　}
　　catch( int& value )
　　{
　　//这个例子中，Func()函数中抛出的异常会在此被处理
　　cout << "在 catch block 中, int数据类型处理异常错误。”<< endl;
　　}
　　//如果这里调用这个函数，那么由于main()已经是调用栈的顶层函数，因此不能找
　　//到对应的catch block，所以程序会执行terminate()退出。
　　Func();
　　// [特别提示]：在C++标准中规定，可以在程序任何地方throw一个异常对象，
　　// 并不要求一定只能是在受到try block监控保护的作用域中才能抛出异常，但
　　// 如果在程序中出现了抛出的找不到对应catch block的异常对象时，C++标
　　// 准中规定要求系统必须执行terminate()来终止程序。
　　// 因此这个例程是可以编译通过的，但运行时却会异常终止。这往往给软件
　　// 系统带来了不安全性。与此形成对比的是java中提供的异常处理模型却是不
　　// 永许出现这样的找不到对应catch block的异常对象，它在编译时就给出错误
　　// 提示，所以java中提供的异常处理模型往往比C++要更完善，后面的章节
　　// 会进一步对这两种异常处理模型进行一个详细的分析比较。
　　return 0;
　　}
　　朋友们!C++中的异常处理模型的语法很简单吧!就是那么(one、two、three、…哈哈!数数呢!)简单的几条规则。怪不得主人公阿愚这么快就喜欢上她了，而且还居然像一个思想家一样总结出一条感想：好的东西往往都是简单的，简单就是美吗!哈哈!还挺臭美的。
　　下一集主人公阿愚愿和大家一起讨论一下C++中的异常处理中的一种特殊的catch用法，那就是关于catch(…)大探秘。
第3集 C++中catch(…)如何使用
　作者：王胜祥　来源：希赛网　2008年1月3日　　进入社区
　　上一篇文章中详细讲了讲C++异 常处理模型的trycatch使用语法，其中catch关键字是用来定义catch block的，它后面带一个参数，用来与异常对象的数据类型进行匹配。注意catch关键字只能定义一个参数，因此每个catch block只能是一种数据类型的异常对象的错误处理模块。如果要想使一个catch block能抓获多种数据类型的异常对象的话，怎么办?C++标准中定义了一种特殊的catch用法，那就是” catch(…)”。
　　感性认识
　　1、catch(…)到底是一个什么样的东东，先来个感性认识吧!看例子先：
　　int main()
　　{
　　try
　　{
　　cout << "在 try block 中, 准备抛出一个异常." << endl;
　　//这里抛出一个异常(其中异常对象的数据类型是int，值为1)
　　throw 1;
　　}
　　//catch( int& value )
　　//注意这里catch语句
　　catch( …)
　　{
　　cout << "在 catch(…) block 中, 抛出的int类型的异常对象被处理" << endl;
　　}
　　}
　　2、哈哈!int类型的异常被catch(…)抓获了，再来另一个例子：
　　int main()
　　{
　　try
　　{
　　cout << "在 try block 中, 准备抛出一个异常." << endl;
　　//这里抛出一个异常(其中异常对象的数据类型是double，值为0.5)
　　throw 0.5;
　　}
　　//catch( double& value )
　　//注意这里catch语句
　　catch( …)
　　{
　　cout << "在 catch(…) block 中, double类型的异常对象也被处理" << endl;
　　}
　　}
　　3、同样，double类型的异常对象也被catch(…)块抓获了。是的，catch(..)能匹配成功所有的数据类型的异常对象，包括 C++语言提供所有的原生数据类型的异常对象，如int、double，还有char*、int*这样的指针类型，另外还有数组类型的异常对象。同时也包 括所有自定义的抽象数据类型。例程如下：
　　int main()
　　{
　　try
　　{
　　cout << "在 try block 中, 准备抛出一个异常." << endl;
　　//这里抛出一个异常(其中异常对象的数据类型是char*)
　　char* p=0;
　　throw p;
　　}
　　//catch( char* value )
　　//注意这里catch语句
　　catch( …)
　　{
　　cout << "在 catch(…) block 中, char*类型的异常对象也被处理" << endl;
　　}
　　}
　　int main()
　　{
　　try
　　{
　　cout << "在 try block 中, 准备抛出一个异常." << endl;
　　//这里抛出一个异常(其中异常对象的数据类型是int[])
　　int a[4];
　　throw a;
　　}
　　//catch( int value[] )
　　//注意这里catch语句
　　catch( …)
　　{
　　cout << "在 catch(…) block 中, int[]类型的异常对象也被处理" << endl;
　　}
　　}
　　4、对于抽象数据类型的异常对象。catch(…)同样有效，例程如下：
　　class MyException
　　{
　　public:
　　protected:
　　int code;
　　};
　　int main()
　　{
　　try
　　{
　　cout << "在 try block 中, 准备抛出一个异常." << endl;
　　//这里抛出一个异常(其中异常对象的数据类型是MyException)
　　throw MyException();
　　}
　　//catch(MyException& value )
　　//注意这里catch语句
　　catch( …)
　　{
　　cout << "在catch(…) block中, MyException类型的异常对象被处理" << endl;
　　}
　　}
　　对catch(…)有点迷糊?
　　1、究竟对catch(…)有什么迷糊呢?还是看例子先吧!
　　void main()
　　{
　　int* p = 0;
　　try
　　{
　　// 注意：下面这条语句虽然不是throw语句，但它在执行时会导致系统
　　// 出现一个存储保护错误的异常(access violation exception)
　　*p = 13; // causes an access violation exception;
　　}
　　catch(...)
　　{
　　//catch(…)能抓获住上面的access violation exception异常吗?
　　cout << "在catch(…) block中" << endl;
　　}
　　}
　　请问上面的程序运行时会出现什么结果吗?catch(…)能抓获住系统中出现的access violation exception异常吗?朋友们!和我们的主人公阿愚一样，自己动手去测试一把!
　　结果又如何呢?实际上它有两种不同的运行结果，在window2000系统下用VC来测试运行这个小程序时，发现程序能输出"在 catch(…) block中"的语句在屏幕上，也即catch(…) 能成功抓获住系统中出现的access violation exception异常，很厉害吧!但如果这个同样的程序在linux下用gcc编译后运行时，程序将会出现崩溃，并在屏幕上输出”segment fault”的错误信息。
　　主人公阿愚有点急了，也开始有点迷糊了，为什么?为什么?为什么同样一个程序在两种不同的系统上有不同的表现呢?其原因就是：对于这种由于硬件或操作系统出 现的系统异常(例如说被零除、内存存储控制异常、页错误等等)时，window2000系统有一个叫做结构化异常处理(Structured Exception Handling，SEH)的机制，这个东东太厉害了，它能和VC中的C++异常处理模型很好的结合上(实际上VC实现的C++异常处理模型很大程度上建 立在SEH机制之上的，或者说它是SEH的扩展，后面文章中会详细阐述并分析这个久富盛名的SEH，看看catch(…)是如何神奇接管住这种系统异常出 现后的程序控制流的，不过这都是后话)。而在linux系统下，系统异常是由信号处理编程方法来控制的(信号处理编程，signal processing progamming。在介绍unix和linux下如何编程的书籍中，都会有对信号处理编程详细的介绍，当然执著的主人公阿愚肯定对它也不会放过，会深 入到unix沿袭下来的信号处理编程内部的实现机制，并尝试完善改进它，使它也能够较好地和C++异常处理模型结合上)。
　　那么C++标准中对于这种同一个程序有不同的运行结果有何解释呢?这里需要注意的是，window2000系统下catch(…)能捕获住系统 异常，这完全是它自己的扩展。在C++标准中并没有要求到这一点，它只规定catch(…)必须能捕获程序中所有通过throw语句抛出的异常。因此上面 的这个程序在linux系统下的运行结果也完全是符合C++标准的。虽然大家也必须承认window2000系统下对C++异常处理模型的这种扩展确实是 一个很不错的完善，极大得提高了程序的安全性。
　　为什么要用catch(…)这个东东?
　　程序员朋友们也许会说，这还有问吗?这篇文章的一开始不就讲到了吗?catch(…)能够捕获多种数据类型的异常对象，所以它提供给程序员一种对异常对象更好的控制手段，使开发的软件系统有很好的可靠性。因此一个比较有经验的程序员通常会这样组织编写它的代码模块，如下：
　　void Func()
　　{
　　try
　　{
　　// 这里的程序代码完成真正复杂的计算工作，这些代码在执行过程中
　　// 有可能抛出DataType1、DataType2和DataType3类型的异常对象。
　　}
　　catch(DataType1& d1)
　　{
　　}
　　catch(DataType2& d2)
　　{
　　}
　　catch(DataType3& d3)
　　{
　　}
　　// 注意上面try block中可能抛出的DataType1、DataType2和DataType3三
　　// 种类型的异常对象在前面都已经有对应的catch block来处理。但为什么
　　// 还要在最后再定义一个catch(…) block呢?这就是为了有更好的安全性和
　　// 可靠性，避免上面的try block抛出了其它未考虑到的异常对象时导致的程
　　// 序出现意外崩溃的严重后果，而且这在用VC开发的系统上更特别有效，因
　　// 为catch(…)能捕获系统出现的异常，而系统异常往往令程序员头痛了，现
　　// 在系统一般都比较复杂，而且由很多人共同开发，一不小心就会导致一个
　　// 指针变量指向了其它非法区域，结果意外灾难不幸发生了。catch(…)为这种
　　// 潜在的隐患提供了一种有效的补救措施。
　　catch(…)
　　{
　　}
　　}
　　还有，特别是VC程序员为了使开发的系统有更好的可靠性，往往在应用程序的入口函数中(如MFC框架的开发环境下 CXXXApp::InitInstance())和工作线程的入口函数中加上一个顶层的trycatch块，并且使用catch(…)来捕获一切所有的 异常，如下：
　　BOOL CXXXApp::InitInstance()
　　{
　　if (!AfxSocketInit())
　　{
　　AfxMessageBox(IDP_SOCKETS_INIT_FAILED);
　　return FALSE;
　　}
　　AfxEnableControlContainer();
　　// Standard initialization
　　// If you are not using these features and wish to reduce the size
　　// of your final executable, you should remove from the following
　　// the specific initialization routines you do not need.
　　#ifdef _AFXDLL
　　Enable3dControls(); // Call this when using MFC in a shared DLL
　　#else
　　Enable3dControlsStatic(); // Call this when linking to MFC statically
　　#endif
　　// 注意这里有一个顶层的trycatch块，并且使用catch(…)来捕获一切所有的异常
　　try
　　{
　　CXXXDlg dlg;
　　m_pMainWnd = &dlg;
　　int nResponse = dlg.DoModal();
　　if (nResponse == IDOK)
　　{
　　// TODO: Place code here to handle when the dialog is
　　// dismissed with OK
　　}
　　else if (nResponse == IDCANCEL)
　　{
　　// TODO: Place code here to handle when the dialog is
　　// dismissed with Cancel
　　}
　　}
　　catch(…)
　　{
　　// dump出系统的一些重要信息，并通知管理员查找出现意外异常的原因。
　　// 同时想办法恢复系统，例如说重新启动应用程序等
　　}
　　// Since the dialog has been closed, return FALSE so that we exit the
　　// application, rather than start the application's message pump.
　　return FALSE;
　　}
　　通过上面的例程和分析可以得出，由于catch(…)能够捕获所有数据类型的异常对象，所以在恰当的地方使用catch(…)确实可以使软件系 统有着更好的可靠性。这确实是大家使用catch(…)这个东东最好的理由。但不要误会的是，在C++异常处理模型中，不只有catch(…)方法能够捕 获几乎所有类型的异常对象(也许有其它更好的方法，在下一篇文章中主人公阿愚带大家一同去探讨一下)，可C++标准中为什么会想到定义这样一个 catch(…)呢?有过java或C#编 程开发经验的程序员会发现，在它们的异常处理模型中，并没有这样类似的一种语法，可这里不得不再次强调的是，java中的异常处理模型是C++中的异常处 理模型的完善改进版，可它反而没有了catch(…)，为何呢?还是先去看看下一章吧，“C++的异常处理和面向对象的紧密关系”。也许大家能找到一个似 乎合理的原因。
第4集 C++的异常处理和面向对象的紧密关系
　作者：王胜祥　来源：希赛网　2008年1月3日　　进入社区
　　如果有人问起C++和 C到底有那些本质上的不同点？主人公阿愚当然也会有自己的一份理解，他会毫不犹豫回答出：“与C相比，C++至少引入了两项重要技术，其一就是对面向对象 的全面支持；还有一项就是C++优良的异常处理模型”。是的，这两项技术对构建出一个优良的可靠复杂的软件系统都太重要了。可这两项技术之间又有何关系 呢？非常客观公正的说，它们之间的关系实在是太紧密了，两者相互支持和依赖，是构建优良可靠复杂的软件系统最不可缺乏的两个东东。
用对象来描述程序中出现的异常

　　虽然前几篇文章的内容中列举的一些小例子程序大多都是throw一些如int、double类型的异常，但程序员朋友都很熟悉，实际开发环境中所抛出的异常都是一个个代表抽象数据类型的对象，如C++标准库中的std::exception()，MFC开发库