十点详解C++异常处理 一文助你全面剖析C++异常处理机制

一，什么是异常处理

一句话：异常处理就是处理程序中的错误，比如尝试除以零的操作。

二，为什么需要异常，以及异常处理的基本思想

C++之父Bjarne Stroustrup在《The C++ Programming Language》中讲到：一个库的作者可以检测出发生了运行时错误，但一般不知道怎样去处理它们(因为和用户具体的应用有关);另一方面，库的用户知道怎样处理这些错误，但却无法检查它们何时发生(如果能检测，就可以在用户的代码里处理了，不用留给库去发现)。

Bjarne Stroustrup说：提供异常的基本目的就是为了处理上面的问题。基本思想是：让一个函数在发现了自己无法处理的错误时抛出(throw)一个异常，然后它的(直接或者间接)调用者能够处理这个问题。

也就是《C++ primer》中说的：将问题检测和问题处理相分离。

一种思想：在所有支持异常处理的编程语言中，要认识到的一个思想：在异常处理过程中，由问题检测代码可以抛出一个对象给问题处理代码，通过这个对象的类型和内容，实际上完成了两个部分的通信，通信的内容是“出现了什么错误”。当然，各种语言对异常的具体实现有着或多或少的区别，但是这个通信的思想是不变的。

三，异常出现之前处理错误的方式

在C语言的世界中，对错误的处理总是围绕着两种方法：一是使用整型的返回值标识错误;二是使用errno宏(可以简单地理解为一个全局整型变量)去记录错误。当然C++中仍然是可以用这两种方法的。

这两种方法最大的缺陷就是会出现不一致问题。例如有些函数返回1表示成功，返回0表示出错;而有些函数返回0表示成功，返回非0表示出错。

还有一个缺点就是函数的返回值只有一个，你通过函数的返回值表示错误代码，那么函数就不能返回其他的值。当然，你也可以通过指针或者C++的引用来返回另外的值，但是这样可能会令你的程序略微晦涩难懂。

四，异常为什么好

优点有以下几点：

1. 函数的返回值可以忽略，但异常不可忽略。如果程序出现异常，但是没有被捕获，程序就会终止，这多少会促使程序员开发出来的程序更健壮一点。而如果使用C语言的error宏或者函数返回值，调用者都有可能忘记检查，从而没有对错误进行处理，结果造成程序莫名其面的终止或出现错误的结果。

2. 整型返回值没有任何语义信息。而异常却包含语义信息，有时你从类名就能够体现出来。

3. 整型返回值缺乏相关的上下文信息。异常作为一个类，可以拥有自己的成员，这些成员就可以传递足够的信息。

异常处理可以在调用跳级。这是一个代码编写时的问题：假设在有多个函数的调用栈中出现了某个错误，使用整型返回码要求你在每一级函数中都要进行处理。而使用异常处理的栈展开机制，只需要在一处进行处理就可以了，不需要每级函数都处理。

五， C++中使用异常时应注意的问题

任何事情都是两面性的，异常有好处就有坏处。如果在你的代码中使用异常，那么需要注意以下事项:

1. 性能问题。这个一般不会成为瓶颈，但是如果你编写的是高性能或者实时性要求比较强的软件，就需要考虑了。

2. 指针和动态分配导致的内存回收问题：动态内存不会自动回收，如果遇到异常就需要考虑是否正确地回收了内存。

函数的异常抛出列表：如果没有写noexcept，意味着你可以抛出任何异常。

六，异常基本语法

很简单，抛出一场用throw，捕获用try...catch

• throw: 当问题出现时，程序会抛出一个异常。
• catch: 在您想要处理问题的地方，通过异常处理程序捕获异常。
• try: try 块中的代码标识将被激活得特定异常。它后面通常跟着一个或多个 catch 块。
• noexcept：用于声明函数不抛出异常，如果函数抛了异常，则直接中断，不能被捕获

使用 try...catch 语句的语法如下所示：

1. try 
2. { 
3.    // 保护代码 
4. }catch( ExceptionName e1 ) 
5. { 
6.    // catch 块 
7. }catch( ExceptionName e2 ) 
8. { 
9.    // catch 块 
10. }catch( ExceptionName eN ) 
11. { 
12.    // catch 块 
13. } 

如果 try 块在不同的情境下会抛出不同的异常，这个时候可以尝试罗列多个 catch 语句，用于捕获不同类型的异常

捕获异常时的注意事项：

1. catch的匹配过程是找最先匹配的，不是最佳匹配。
2. catch的匹配过程中，对类型的要求比较严格。不允许标准算术转换和类类型的转换。(类类型的转化包括两种：通过构造函数的隐式类型转化和通过转化操作符的类型转化)。

七，异常之栈解旋

异常被抛出后，从进入try块起，到异常被抛掷前，这期间在栈上构造的所有对象，都会被自动析构。

析构的顺序与构造的顺序相反，这一过程称为栈的解旋(unwinding).

1. struct Maker 
2. { 
3.     Maker() 
4.     { 
5.         cout << "Maker() 构造函数" << endl; 
6.     } 
7.     Maker(const Maker& other) 
8.     { 
9.         cout << "Maker(Maker&) 拷贝构造函数" << endl; 
10.     } 
11.     ~Maker() 
12.     { 
13.         cout << "~Maker() 析构函数" << endl; 
14.     } 
15. }; 
16. void fun() 
17. { 
18.     Maker m; 
19.     cout << "--------" << endl; 
20.     throw m; 
21.     cout << "fun__end" << endl; 
22. } 
23. int main() 
24. { 
25.     try 
26.     { 
27.         fun(); 
28.     } 
29.     catch (Maker & m) 
30.     { 
31.         cout << "收到Maker异常" << endl; 
32.     } 
33. } 

 八，C++ 标准的异常

C++ 提供了一系列标准的异常，定义在 中，我们可以在程序中使用这些标准的异常。它们是以父子类层次结构组织起来的，如下所示：

每个类所在的头文件在图下方标识出来

标准异常类的成员： ① 在上述继承体系中，每个类都有提供了构造函数、复制构造函数、和赋值操作符重载。 ② logic_error类及其子类、runtime_error类及其子类，它们的构造函数是接受一个string类型的形式参数，用于异常信息的描述; ③ 所有的异常类都有一个what()方法，返回const char* 类型(C风格字符串)的值，描述异常信息。

下表是对上面层次结构中出现的每个异常的说明：

九、编写自己的异常类

• 为什么要编写自己的异常类? ① 标准库中的异常是有限的; ② 在自己的异常类中，可以添加自己的信息。(标准库中的异常类值允许设置一个用来描述异常的字符串)。
• 如何编写自己的异常类? ① 建议自己的异常类要继承标准异常类。因为C++中可以抛出任何类型的异常，所以我们的异常类可以不继承自标准异常，但是这样可能会导致程序混乱，尤其是当我们多人协同开发时。 ② 当继承标准异常类时，应该重载父类的what函数和虚析构函数。 ③ 因为栈展开的过程中，要复制异常类型，那么要根据你在类中添加的成员考虑是否提供自己的复制构造函数。

示例：

1. #include <iostream> 
2. #include <exception> 
3. using namespace std; 
4.  //第一种 
5. class Out_Range : public exception 
6. { 
7. public: 
8.     explicit Out_Range(const string& _Message) : exception(_Message.c_str()) {} 
9.     explicit Out_Range(const char* _Message) : exception(_Message) {} 
10. }; 
11. //第二种 
12. struct Exce :public exception 
13. { 
14.     const char* what() const override 
15.     { 
16.         return "Exce"; 
17.     } 
18. }; 
19.   
20. void foo(int arr[], int len) 
21. { 
22.     int i = -1; 
23.     if (i<0 || i>=len) 
24.     { 
25.         throw Out_Range("数组越界啦~"); 
26.     } 
27.     cout << arr[i] << endl; 
28. } 
29.  
30. int main() 
31. { 
32.     int arr[3] = { 0 }; 
33.     try 
34.     { 
35.         foo(arr, 3); 
36.     } 
37.     catch (Out_Range& e)        //自定义错误 
38.     { 
39.         cout << "Out_Range& e   " << e.what() << endl; 
40.     } 
41.     catch (std::exception& e)   //其他错误 
42.     { 
43.         cout <<"std::exception& e   "<<e.what()<< endl; 
44.     } 
45.     return 0; 
46. } 

 十，来自C++之父Bjarne Stroustrup的建议

节选自《The C++ Programming Language》 ——C++之父Bjarne Stroustrup

1. 当局部的控制能够处理时，不要使用异常;

2.使用“资源分配即初始化”技术去管理资源;

3. 尽量少用try-catch语句块，而是使用“资源分配即初始化”技术。

4. 如果构造函数内发生错误，通过抛出异常来指明。

5. 避免在析构函数中抛出异常。

6. 保持普通程序代码和异常处理代码分开。

7. 小心通过new分配的内存在发生异常时，可能造成内存泄露。

8. 如果一个函数可能抛出某种异常，那么我们调用它时，就要假定它一定会抛出该异常，即要进行处理。

9. 要记住，不是所有的异常都继承自exception类。

10. 编写的供别人调用的程序库，不应该结束程序，而应该通过抛出异常，让调用者决定如何处理(因为调用者必须要处理抛出的异常)。

原文地址：https://www.toutiao.com/i6942756782083195422/