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

时间:2021-10-12 20:36:45

十点详解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. }catch( ExceptionName e1 ) 
  4.    // catch 块 
  5. }catch( ExceptionName e2 ) 
  6.    // catch 块 
  7. }catch( ExceptionName eN ) 
  8.    // catch 块 

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

捕获异常时的注意事项:

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

七,异常之栈解旋

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

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

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

 八,C++ 标准的异常

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

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

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

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

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

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

九、编写自己的异常类

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

示例:

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

 十,来自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/