C++中的异常处理（五十三）
我们在上节博客中讲了 C 语言中的异常处理，今天我们就来讲下 C++ 中的异常处理。在 C++ 中内置异常处理的语法元素 try ... catch ...，try 语句处理正常代码逻辑，catch 语句处理异常情况，try 语句中的异常由相对应的 catch 语句处理。C++ 通过 throw 语句抛出异常信息，throw 抛出的异常必须被 catch 处理，当前函数能够处理异常，程序继续往下执行；当前函数无法处理异常，则函数停止执行并返回。未被处理的异常会顺着函数调用栈向上传播，直到被处理为止，否则程序将停止执行。如下
创新互联专注于企业营销型网站、网站重做改版、洛川网站定制设计、自适应品牌网站建设、HTML5、商城系统网站开发、集团公司官网建设、成都外贸网站建设、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为洛川等各大城市提供网站开发制作服务。
下来我们就以代码为例来进行分析
#include#include using namespace std; double divide(double a, double b) { const double delta = 0.000000000000001; double ret = 0; if( !((-delta < b) && (b < delta)) ) { ret = a / b; } else { throw 0; } return ret; } int main() { try { double r = divide(1, 0); cout << "r = " << r << endl; } catch(...) { cout << "Divided by zero..." << endl; } return 0; }
我们来看看编译结果
我们再来试试 1/1 呢
已经正确实现了哈。C++ 的这个异常处理是不是很方便呢。同一个 try 语句是可以跟上多个 catch 语句的。catch 语句可以定义具体处理的异常类型，不同类型的异常由不同的 catch 语句负责处理；try 语句中可以抛出任何类型的异常，catch(...) 用于处理所有类型的异常，任何异常都只能被捕获（catch）一次。下来我们来看看异常处理的匹配规则，如下
下来我们还是以代码为例来进行说明
#include#include using namespace std; void Demo1() { try { throw 0; } catch(char c) { cout << "catch(char c)" << endl; } catch(short c) { cout << "catch(short c)" << endl; } catch(double c) { cout << "catch(double c)" << endl; } catch(int c) { cout << "catch(int c)" << endl; } } void Demo2() { throw "D.T.Software"; } int main() { try { Demo1(); //Demo2(); } catch(char* s) { cout << "catch(char* s)" << endl; } catch(const char* cs) { cout << "catch(const char* cs)" << endl; } catch(string ss) { cout << "catch(string ss)" << endl; } return 0; }
我们来看看会打印出什么
我们看到直接在最后匹配到了 int，因为抛出的 0 默认类型为 int，它不会进行默认类型的转换。我们再来看看 Demo2 会打印出什么
因为字符串是字面量，所以它会匹配到 const char* cs 上，如果我们在 Demo2 函数中抛出的是 string("D.T.Software")；看看会打印出什么
便会打印出字符串了。那么在 catch语句中我们还可以抛出异常，如下
那么我们为什么要在 catch 语句中重新抛出异常呢？catch 中捕获的异常可以被重新解释后抛出，在工程开发中使用这样的方式统一异常类型，如下
那么我们还是以代码为例来进行讲解
#include#include using namespace std; void Demo() { try { try { throw 'c'; } catch(int i) { cout << "Inner: catch(int i)" << endl; throw i; } catch(...) { cout << "Inner: catch(...)" << endl; throw; } } catch(...) { cout << "Outer: catch(...)" << endl; } } /* 假设： 当前的函数式第三方库中的函数，因此，我们无法修改源代码 函数名： void func(int i) 抛出异常的类型： int -1 ==> 参数异常 -2 ==> 运行异常 -3 ==> 超时异常 */ void func(int i) { if( i < 0 ) { throw -1; } if( i > 100 ) { throw -2; } if( i == 11 ) { throw -3; } cout << "Run func..." << endl; } void MyFunc(int i) { try { func(i); } catch(int i) { switch(i) { case -1: throw "Invalid Parameter"; break; case -2: throw "Runtime Exception"; break; case -3: throw "Timeout Exception"; break; } } } int main() { Demo(); /* try { MyFunc(11); } catch(const char* cs) { cout << "Exception Info: " << cs << endl; } */ return 0; }
我们先以 Demo 函数为例来进行分析，在 try 语句中的 try 语句里抛出 c，匹配到 catch(...) 语句中，先打印出 Inner: catch(...)，再次抛出。匹配到外面的 catch(...) 语句中，先打印出 Outer: catch(...)。我们来看看结果
我们看到和我们的分析是完全一致的。接下来的 func 函数就比如是第三方的源码，我们得根据这个功能写个一个属于我们自己的 func 函数。我们改写完之后是不是就一目了然呢？比如没改写之前，抛出个 11 的异常，对应的便会打印出 -3，我们还得去查这个 -3 代表啥意思。我们来注释掉 Demo 函数，看看下面的编译结果
输出结果一目了然，直接看到是超时异常。那么我们便直接定位到了问题，这样效率便会提高。在 C++ 中，异常的类型可以是自定义类类型，对于类类型异常的匹配依旧是至上而下严格匹配，赋值兼容性原则在异常匹配中依然适用。一般而言，将匹配子类异常的 catch 放在上部，匹配父类异常的 catch 放在下部。在工程中会定义一系列的异常类，每个类代表工程中可能出现的一种异常类型。代码复用时可能需要解释不同的异常类，在定义 catch 语句时需要推荐使用引用作为参数。
接下来我们还是以代码为例来进行分析
#include#include using namespace std; class Base { }; class Exception : public Base { int m_id; string m_desc; public: Exception(int id, string desc) { m_id = id; m_desc = desc; } int id() const { return m_id; } string description() const { return m_desc; } }; /* 假设： 当前的函数式第三方库中的函数，因此，我们无法修改源代码 函数名： void func(int i) 抛出异常的类型： int -1 ==> 参数异常 -2 ==> 运行异常 -3 ==> 超时异常 */ void func(int i) { if( i < 0 ) { throw -1; } if( i > 100 ) { throw -2; } if( i == 11 ) { throw -3; } cout << "Run func..." << endl; } void MyFunc(int i) { try { func(i); } catch(int i) { switch(i) { case -1: throw Exception(-1, "Invalid Parameter"); break; case -2: throw Exception(-2, "Runtime Exception"); break; case -3: throw Exception(-3, "Timeout Exception"); break; } } } int main() { try { MyFunc(11); } catch(const Exception& e) { cout << "Exception Info: " << endl; cout << " ID: " << e.id() << endl; cout << " Description: " << e.description() << endl; } catch(const Base& e) { cout << "catch(const Base& e)" << endl; } return 0; }
我们看到定义了两个类，在类 Exception 中定义了 id 和 description 用来描述他们的信息，再在 MyFunc 函数中生成临时对象 Exception 用来获取他们的信息，我们来看看编译结果
这样的信息是不是更加直观呢。如果我们将上面的 catch 语句中的父类放在子类前面呢，看看结果
我们看到编译已经警告了，运行后它打印的是父类的信息，因为它同样遵循赋值兼容性原则。我们在之前说的，将匹配子类异常的 catch 放在上部，匹配父类异常的 catch 放在下部。一定要遵循这个规则。在 C++ 标准库中提供了实用异常类族，标准库中的异常都是从 exception 类派生的，exception 类有两个主要的分支：a> logic_error 常用于程序中可避免逻辑错误；b> runtime_error 常用于程序中无法避免的恶性错误。下图是标准库中的异常类关系
通过对异常的学习，总结如下：1、C++ 中直接支持异常处理的概念；2、try...catch..是 C++ 中异常处理的专用语句；3、try 语句处理正常代码逻辑，catch 语句处理异常情况，同一个 try 语句可以跟上多个 catch 语句；4、异常处理必须严格匹配，不进行任何的转换；5、catch 语句块中可以抛出异常，异常的类型可以是自定义类类型；6、赋值兼容性原则在异常匹配中依然适用；7、标准库中的异常都是从 exception 类派生的。
欢迎大家一起来学习 C++ 语言，可以加我QQ：243343083。
当前文章：C++中的异常处理（五十三）
本文网址：http://6mz.cn/article/jsgico.html