C++ 异常处理
文章目录
-
C++ 异常处理
-
- 异常关键字
-
- 异常处理实例
-
- C++ 标准异常
-
- 自定义异常
-
- 被遗弃的标准
1. 异常关键字
异常是程序在 执行期间 产生的问题。C++ 异常是指在程序运行时发生的特殊情况，比如尝试除以零的操作。
异常提供了一种 转移程序控制权 的方式。
C++ 异常处理涉及到三个关键字：try、catch、throw。
throw
当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。
catch
在您想要处理问题的地方，通过异常处理程序捕获异常。catch 关键字用于捕获异常。
try
try关键字覆盖范围中的代码称为保护代码，这些代码可能通过 throw 关键字抛出异常，它后面通常跟着一个或多个 catch 块。
异常必须被抛出，才可以被捕获。也就是说如果想要 try / catch，必须有 throw。
使用 try / catch 语句的语法如下所示：
2
3
4
5
6
7
8
9
10
11
12
13
14
2{
3 // 可能通过 throw 抛出异常
4}
5catch( ExceptionName e1 )
6{
7 //捕获 ExceptionName 类型的异常并处理
8}
9catch( ExceptionName e2 )
10{
11 //捕获 ExceptionName 类型的异常并处理
12}
13
14
2. 异常处理实例
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2using namespace std;
3
4double division(int a, int b)
5{
6 if( b == 0 ){throw "Division by zero condition!";}
7 return (a/b);
8}
9
10int main ()
11{
12 int x = 50;
13 int y = 0;
14 double z = 0;
15
16 try
17 {
18 z = division(x, y);
19 cout << z << endl;
20 }
21 catch (const char* msg) {cerr << msg << endl;}
22
23 return 0;
24}
25
26
我们需要 保证抛出异常与捕获异常的类型相匹配，这里抛出了一个类型为 const char* 的异常，因此，当捕获该异常时，我们必须在 catch 块中使用 const char*；如果抛出的是 int ，那么捕获的时候也该是 int。
如果类型不匹配，那么是无法捕获异常的，程序会调用 adort 函数 终止程序。
catch(…) 表示捕捉任何类型的异常，不会存在类型不匹配的问题，缺点在于只能检测到出现异常，不能发现到底是哪里出现异常。
前面说到，一旦出现抛出异常没被处理的问题，系统将自动调用 abort() 函数，实际上，它触发的是 terminate，我们可以自定义 terminate 的处理方法：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
2#include<iostream>
3using namespace std;
4
5void check(int y)
6{
7 if(y==0) throw "exception";
8}
9
10void myTerminate()
11{
12 cout<<"Unhandler exception!\n";
13 exit(-1);
14}
15
16int main()
17{
18 terminate_handler preHandler=set_terminate(myTerminate);
19 int x=100,y=0;
20 try
21 {
22 check(y);
23 cout<<x/y;
24 }
25 catch(int &e) //no catch sentence matches the throw type
26 {
27 cout<<e<<endl;
28 }
29
30 return 0;
31}
32
33
异常类型不匹配，无法捕获异常，系统调用自定义 terminate 方法。
如果注释掉：
terminate_handler preHandler=set_terminate(myTerminate);
3. C++ 标准异常
C++ 提供了一系列标准的异常，定义在 “《exception》” 中，我们可以在程序中使用这些标准的异常。它们是以父子类层次结构组织起来的，如下所示：
std::exception
该异常是所有标准 C++ 异常的父类。
std::bad_alloc
该异常可以通过 new 抛出。
std::bad_cast
该异常可以通过 dynamic_cast 抛出。
std::bad_exception
这在处理 C++ 程序中无法预期的异常时非常有用。
std::bad_typeid
该异常可以通过 typeid 抛出。
std::logic_error
理论上可以通过读取代码来检测到的异常。
std::domain_error
当使用了一个无效的数学域时，会抛出该异常。
std::invalid_argument
当使用了无效的参数时，会抛出该异常。
std::length_error
当创建了太长的 std::string 时，会抛出该异常。
std::out_of_range
该异常可以通过方法抛出，例如 std::vector 和 std::bitset<>::operator。
std::runtime_error
理论上不可以通过读取代码来检测到的异常。
std::overflow_error
当发生数学上溢时，会抛出该异常。
std::range_error
当尝试存储超出范围的值时，会抛出该异常。
std::underflow_error
当发生数学下溢时，会抛出该异常。
4. 自定义异常
用户可以自定义异常类型，异常类型并不受到限制，可以是内建数据类型如 int,double等，也可以是自定义的类，也可以从C++某个异常类继承下来。
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
2#include<iostream>
3using namespace std;
4
5/*自定义异常类 myException，重载 exception 的 what 方法*/
6class myException:public exception
7{
8public:
9 const char* what()const throw()
10 {
11 return "ERROR! Don't divide a number by integer zero.\n";
12 }
13};
14
15void check(int y)
16{
17 if(y==0) throw myException();
18}
19
20
21int main()
22{
23
24 int x=100,y=0;
25 try
26 {
27 check(y);
28 cout<<x/y;
29 }
30 catch(myException& e)
31 {
32 cout << e.what() << endl;
33 }
34 return 0;
35}
36
37
what() 是异常类提供的一个公共方法，它已被所有子异常类重载。这将返回异常产生的原因。
如果你想捕获标准异常 bad_alloc 抛出的异常，可以这样做。
2
3
4
5
6
2{
3 cout << e.what() << endl;
4}
5
6
5. 被遗弃的标准
throw 关键字除了可以用在函数体中抛出异常，还可以用在函数头和函数体之间，指明函数能够抛出的异常类型。有些文档中称为异常列表。例如：
double func (char param) throw (int);
如果希望能够抛出多种类型的异常，可以用逗号隔开：
double func (char param) throw (int, char, exception);
如果不希望限制异常类型，那么可以省略：
double func (char param) throw ();
**C++标准已经不建议这样使用 throw 关键字了，**因为各个编译器对 throw 的支持不同，有的直接忽略，不接受 throw 的限制，有的将 throw 作为函数签名，导致引用函数时可能会有问题。上面的代码在 GCC 下运行时会崩溃，在 VS 下运行时则直接忽略 throw 关键字对异常类型的限制，try 可以正常捕获到抛出的异常，程序并不会崩溃。
