C++/C++11中std::runtime_error的使用

std::runtime_error：运行时错误异常类，只有在运行时才能检测到的错误，继承于std::exception，它的声明在头文件中。std::runtime_error也用作几个运行时错误异常的基类，包括std::range_error(生成的结果超出了有意义的值域范围)、overflow_error(上溢)、underflow_error(下溢)、system_error(系统错误)。std::runtime_error类没有默认构造函数，有两个声明为explicit的构造函数，一个接收参数为const char*类型，一个接收参数为const std::string&，这些实参负责提供关于错误的更多信息。std::runtime_error类还有一个继承自std::exception类的what虚函数，返回关于异常的一些文本信息。

以下内容摘自：《C++Primer(Fifth Edition)》

异常是指在程序运行时发生的反常行为，这些行为超出了函数正常功能的范围。典型的异常包括失去数据库连接以及遇到意外输入等。当程序的某部分检测到一个它无法处理的问题时，需要用到异常处理。此时，检测出问题的部分应该发出某种信号以表明程序遇到了故障，无法继续下去了，而且信号的发出方无须知道故障将在何处得到解决。一旦发出异常信号，检测出问题的部分也就完成了任务。

异常提供了一种转移程序控制权的方式。C++异常处理涉及到三个关键字：try、catch、throw。关于这三个关键字的简单使用可以参考: http://blog.csdn.net/fengbingchun/article/details/65939258

    异常处理机制为程序中异常检测和异常处理这两部分的协作提供支持。在C++语言中，异常处理包括：

    (1)、throw表达式(throw expression)：异常检测部分使用throw表达式来表示它遇到了无法处理的问题。throw引发(raise)异常。throw表达式包含关键字throw和紧随其后的一个表达式，其中表达式的类型就是抛出的异常类型。throw表达式后面通常紧跟一个分号，从而构成一条表达式语句。抛出异常将终止当前的函数，并把控制权转移给能处理该异常的代码。

    (2)、try语句块(try block)：异常处理部分使用try语句块处理异常。try语句块以关键字try开始，并以一个或多个catch子句(catch clause)结束。try语句块中代码抛出的异常通常会被某个catch子句处理。因为catch子句处理异常，所以它们也被称作异常处理代码(exception handler)。catch子句包括三部分：关键字catch、括号内一个(可能未命名的)对象的声明(称作异常声明，exception declaration)以及一个块。当选中了某个catch子句处理异常之后，执行与之对应的块。catch一旦完成，程序跳转到try语句块最后一个catch子句之后的那条语句继续执行。一如往常，try语句块声明的变量在块外部无法访问，特别是在catch子句内也无法访问。如果一段程序没有try语句块且发生了异常，系统会调用terminate函数并终止当前程序的执行。

    (3)、一套异常类(exception class)：用于在throw表达式和相关的catch子句之间传递异常的具体信息。

    函数在寻找处理代码的过程中退出：寻找处理代码的过程与函数调用链刚好相反。当异常被抛出时，首先搜索抛出该异常的函数。如果没有找到匹配的catch子句，终止该函数，并在调用该函数的函数中继续寻找。如果还是没有找到匹配的catch子句，这个新的函数也被终止，继续搜索调用它的函数。以此类推，沿着程序的执行路径逐层回退，直到找到适当类型的catch子句为止。如果最终还是没能找到任何匹配的catch子句，程序转到名为terminate的标准库函数。该函数的行为与系统有关，一般情况下，执行该函数将导致程序非正常退出。

    如果一段程序没有try语句块且发生了异常，系统会调用terminate函数并终止当前程序的执行。

    那些在异常发生期间正确执行了”清理”工作的程序被称作异常安全(exception safe)的代码。编写异常安全的代码非常困难。
1
2
3
4
5
6
7
8
9
10
11
12
13

标准异常：C++标准库定义了一组类，用于报告标准库函数遇到的问题。这些异常类也可以在用户编写的程序中使用，它们分别定义在4个头文件中：

(1)、exception头文件定义了最通常的异常类exception，它只报告异常的发生，不提供任何额外的信息。

(2)、stdexcept头文件定义了几种常用的异常类，如下:

(3)、new头文件定义了bad_alloc异常类型。

(4)、type_info头文件定义了bad_cast异常类型。

标准库异常类只定义了几种运算，包括创建或拷贝异常类型的对象，以及为异常类型的对象赋值。我们只能以默认初始化的方式初始化exception、bad_alloc和bad_cast对象，不允许为这些对象提供初始值。其它异常类型的行为则恰恰相反：应该使用string对象或者C风格字符串初始化这些类型的对象，但是不允许使用默认初始化的方式。当创建此类对象时，必须提供初始值，该初始值含有错误相关的信息。

异常类型只定义了一个名为what的成员函数，该函数没有任何参数，返回值是一个指向C风格字符串的const char*。该字符串的目的是提供关于异常的一些文本信息。what函数返回的C风格字符串的内容与异常对象的类型有关。如果异常类型有一个字符串初始值，则what返回该字符串。对于其它无初始值的异常类型来说，what返回的内容由编译器决定。

异常处理(exception handling)机制允许程序中独立开发的部分能够在运行时就出现的问题进行通信并做出相应的处理。异常使得我们能够将问题的检测与解决过程分离开来。程序的一部分负责检测问题的出现，然后解决该问题的任务传递给程序中的另一部分。检测环节无须知道问题处理模块的所有细节，反之亦然。

    抛出异常：在C++语言中，我们通过抛出(throwing)一条表达式来引发(raised)一个异常。被抛出的表达式的类型以及当前的调用链共同决定了哪段处理代码(handler)将被用来处理该异常。被选中的处理代码是在调用链中与抛出对象类型匹配的最近的处理的代码。其中，根据抛出对象的类型和内容，程序的异常抛出部分将会告知异常处理部分到底发生了什么错误。

    当执行一个throw时，跟在throw后面的语句将不再被执行，throw语句的用法有点类似于return语句：它通常作为调节语句的一部分或者作为某个函数的最后(或者唯一)一条语句。相反，程序的控制权从throw转移到与之匹配的catch模块。该catch可能是同一个函数中的局部catch，也可能位于直接或间接调用了发生异常的函数的另一个函数中。

    当抛出一个异常后，程序暂停当前函数的执行过程并立即开始寻找与异常匹配的catch子句。当throw出现在一个try语句块内时，检查与该try块关联的catch子句。如果找到了匹配的catch，就使用该catch处理异常。如果这一步没找到匹配的catch且该try语句嵌套在其它try块中，则继续检查与外层try匹配的catch子句。如果还是找不到匹配的catch，则退出当前的函数，在调用当前函数的外层函数中继续寻找，依次类推。这一过程被称为栈展开(stack unwinding)过程。栈展开过程沿着嵌套函数的调用链不断查找，直到找到了与异常匹配的catch子句为止：或者也可能一直没找到匹配的catch，则退出主函数后查找过程终止。

    假设找到了一个匹配的catch子句，则程序进入该子句并执行其中的代码。当执行完这个catch子句后，找到与try块关联的最后一个catch子句之后的点，并从这里继续执行。如果没找到匹配的catch子句，程序将退出。因为异常通常被认为是妨碍程序正常执行的事件，所以一旦引发了某个异常，就不能对它置之不理。当找不到匹配的catch时，程序将调用标准库函数terminate，terminate负责终止程序的执行过程。

    Note：一个异常如果没有被捕获，则它将终止当前的程序。

    栈展开过程中对象被自动销毁：在栈展开过程中，位于调用链上的语句块可能会提前退出。通常情况下，程序在这些块中创建了一些局部对象。块退出后它的局部对象也将随之销毁，这条规则对于栈展开过程同样适用。如果在栈展开过程中退出了某个块，编译器将负责确保在这个块中创建的对象能被正确地销毁。如果某个局部对象的类型是类类型，则该对象的析构函数将被自动调用。与往常一样，编译器在销毁内置类型的对象时不需要做任何事情。

    析构函数与异常：析构函数总是会被执行的。出于栈展开可能使用析构函数的考虑，析构函数不应该抛出不能被它自身处理的异常。换句话说，如果析构函数需要执行某个可能抛出异常的操作，则该操作应该被放置在一个try语句块当中，并且在析构函数内部得到处理。一旦在栈展开的过程中析构函数抛出了异常，并且析构函数自身没能捕获到异常，则程序将被终止。

    异常对象(exception object)：是一种特殊的对象，编译器使用异常抛出表达式来对异常对象进行拷贝初始化。因此，throw语句中的表达式必须拥有完全类型。而且如果该表达式是类类型的话，则相应的类必须含有一个可访问的析构函数和一个可访问的拷贝或移动构造函数。如果该表达式是数组类型或函数类型，则表达式将被转换成与之对应的指针类型。异常对象位于由编译器管理的空间中，编译器确保无论最终调用的是哪个catch子句都能访问该空间。当异常处理完毕后，异常对象被销毁。如果退出了某个块，则同时释放块中局部对象使用的内存。因此，抛出一个指向局部对象的指针几乎肯定是一种错误的行为。出于同样的原因，从函数中返回指向局部对象的指针也是错误的。当我们抛出一条表达式时，该表达式的静态编译时类型决定了异常对象的类型。如果一条throw表达式解引用一个基类指针，而该指针实际指向的是派生类对象，则抛出的对象将被切掉一部分，只有基类部分被抛出。

    捕获异常：catch子句(catch clause)中的异常声明(exception declaration)看起来像是只包含一个形参的函数形参列表。像在形参列表中一样，如果catch无须访问抛出的表达式的话，则我们可以忽略捕获形参的名字。声明的类型决定了处理代码所能捕获的异常类型.这个类型必须是完全类型，它可以是左值引用，但不能是右值引用。

    当进入一个catch语句后，通过异常对象初始化异常声明中的参数。和函数的参数类似，如果catch的参数类型是非引用类型，则该参数是异常对象的一个副本，在catch语句内改变参数实际上改变的是局部副本而非异常对象本身；相反，如果参数是引用类型，则和其它引用参数一样，该参数是异常对象的一个别名，此时改变参数也就是改变异常对象。

    catch的参数还有一个特性也与函数的参数非常类似：如果catch的参数是基类类型，则我们可以使用其派生类类型的异常对象对其进行初始化。此时，如果catch的参数是非引用类型，则异常对象将被切掉一部分，这与将派生类对象以值传递的方式传给一个普通函数差不多。另一方面，如果catch的参数是基类的引用，则该参数将以常规方式绑定到异常对象上。

    异常声明的静态类型将决定catch语句所能执行的操作。如果catch的参数是基类类型，则catch无法使用派生类特有的任何成员。

    通常情况下，如果catch接受的异常与某个继承体系有关，则最好将该catch的参数定义成引用类型。

    查找匹配的处理代码：在搜索catch语句的过程中，我们最终找到的catch未必是异常的最佳匹配。相反，挑选出来的应该是第一个与异常匹配的catch语句。因此，越是专门的catch越应该置于整个catch列表的前端。因为catch语句是按照其出现的顺序逐一进行匹配的，所以当程序使用具有继承关系的多个异常时必须对catch语句的顺序进行组织和管理，使得派生类异常的处理代码出现在基类异常的处理代码之前。

    与实参和形参的匹配规则相比，异常和catch异常声明的匹配规则受到更多限制。此时，绝大多数类型转换都不被允许，除了一些极细小的差别之外，要求异常的类型和catch声明的类型是精确匹配的：
1
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

(1)、允许在非常量向常量的类型转换，也就是说，一条非常量对象的throw语句可以匹配一个接受常量引用的catch语句。

(2)、允许从派生类向基类的类型转换。

(3)、数组被转换成指向数组(元素)类型的指针，函数被转换成指向该函数类型的指针。

除此之外，包括标准算术类型转换和类类型转换在内，其它所有转换规则都不能在匹配catch的过程中使用。

如果在多个catch语句的类型之间存在着继承关系，则我们应该把继承链最低端的类(most derived type)放在前面，而将继承链最顶端的类(least derived type)放在后面。

重新抛出：有时，一个单独的catch语句不能完整地处理某个异常。在执行了某些校正操作之后，当前的catch可能会决定由调用链更上一层的函数接着处理异常。一条catch语句通过重新抛出(rethrowing)的操作将异常传递给另外一个catch语句。这里的重新抛出仍然是一条throw语句，只不过不包含任何表达式：throw;

空的throw语句只能出现在catch语句或catch语句直接或间接调用的函数之内。如果在处理代码之外的区域遇到了空throw语句，编译器将调用terminate。

一个重新抛出语句并不指定新的表达式，而是将当前的异常对象沿着调用链向上传递。

很多时候，catch语句会改变其参数的内容。如果在改变了参数的内容后catch语句重新抛出异常，则只有当catch异常声明是引用类型时我们对参数所做的改变才会被保留并继续传播。

捕获所有异常的处理代码：为了一次性捕获所有异常，我们使用省略号作为异常声明，这样的处理代码称为捕获所有异常(catch-all)的处理代码，形如catch(…)。一条捕获所有异常的语句可以与任意类型的异常匹配。

catch(…)通常与重新抛出语句一起使用，其中catch执行当前局部能完成的工作，随后重新抛出异常。

catch(…)既能单独出现，也能与其它几个catch语句一起出现。

如果catch(…)与其它几个catch语句一起出现，则catch(…)必须在最后的位置。出现在捕获所有异常语句后面的catch语句将永远不会被匹配。

函数try语句块与构造函数：通常情况下，程序执行的任何时刻都可能发生异常，特别是异常可能发生在处理构造函数初始值的过程中。构造函数在进入其函数体之前首先执行初始值列表。因为在初始值列表抛出异常时构造函数体内的try语句块还未生效，所以构造函数体内的catch语句无法处理构造函数初始值列表抛出的异常。要想处理构造函数初始值抛出的异常，我们必须将构造函数写出函数try语句块(也称为函数测试块，function try block)的形式。函数try语句块使得一组catch语句既能处理构造函数体(或析构函数体)，也能处理构造函数的初始化过程(或析构函数的析构过程)。

在初始化构造函数的参数时也可能发生异常，这样的异常不属于函数try语句块的一部分。函数try语句块只能处理构造函数开始执行后发生的异常。和其它函数调用一样，如果在参数初始化的过程中发生了异常，则该异常属于调用表达式的一部分，并将在调用者所在的上下文中处理。

处理构造函数初始值异常的唯一方法是将构造函数写成函数try语句块。

noexcept异常说明：在C++11新标准中，我们可以通过提供noexcept说明(noexcept specification)指定某个函数不会抛出异常。其形式是关键字noexcept紧跟在函数的参数列表后面，用以标识该函数不会抛出异常。

对于一个函数来说，noexcept说明要么出现在该函数的所有声明语句和定义语句中，要么一次也不出现。该说明应该在函数的尾置返回类型之前。我们也可以在函数指针的声明和定义中指定noexcept。在typedef或类型别名中则不能出现noexcept。在成员函数中，noexcept说明符需要跟在const及引用限定符之后，而在final、override或虚函数的=0之前。

违反异常说明：如果一个函数在说明了noexcept的同时又含有throw语句或者调用了可能抛出异常的其它函数，编译器将顺利编译通过，并不会因为这种违反异常说明的情况而报错(不排除个别编译器会对这种用法提出警告)。一旦一个noexcept函数抛出了异常，程序就会调用terminate以确保遵守不在运行时抛出异常的承诺。noexcept可以用在两种情况下，一是我们确认函数不会抛出异常；二是我们根本不知道该如何处理异常。

通常情况下，编译器不能也不必在编译时验证异常说明。

如果函数被设计为是throw()的，则意味着该函数将不会抛出异常：void f(int) throw();

异常说明的实参：noexcept说明符接受一个可选的实参，该实参必须能转换为bool类型：如果实参是true，则函数不会抛出异常；如果实参是false，则函数可能抛出异常。

noexcept运算符：noexcept说明符的实参常常与noexcept运算符(noexcept orerator)混合使用。noexcept运算符是一个一元运算符，它的返回值是一个bool类型的右值常量表达式，用于表示给定的表达式是否会抛出异常。和sizeof类似，noexcept也不会求其运算对象的值。

noexcept有两层含义：当跟在函数参数列表后面时它是异常说明符；而当作为noexcept异常说明的bool实参出现时，它是一个运算符。

异常说明与指针、虚函数和拷贝控制：尽管noexcept说明符不属于函数类型的一部分，但是函数的异常说明仍然会影响函数的使用。函数指针及该指针所指的函数必须具有一致的异常说明。也就是说，如果我们为某个指针做了不抛出异常的说明，则该指针将只能指向不抛出异常的函数。相反，如果我们显示或隐式地说明了指针可能抛出异常，则该指针可以指向任何函数，即使是承诺了不抛出异常的函数也可以。

如果一个虚函数承诺了它不会抛出异常，则后续派生出来的虚函数也必须做出同样的承诺；与之相反，如果基类的虚函数允许抛出异常，则派生类的对应函数既可以允许抛出异常，也可以不允许抛出异常。

当编译器合成拷贝控制成员时，同时也生成一个异常说明。如果对所有成员和基类的所有操作都承诺了不会抛出异常，则合成的成员是noexcept的。如果合成成员调用的任意一个函数可能抛出异常，则合成的成员是noexcept(false)。而且，如果我们定义了一个析构函数但是没有为它提供异常说明，则编译器将合成一个。合成的异常说明将与假设由编译器为类合成析构函数时所得的异常说明一致。

异常类层次：标准库异常类构成了下图所示的继承体系：

类型exception仅仅定义了拷贝构造函数、拷贝赋值运算符、一个虚析构函数和一个名为what的虚成员。其中what函数返回一个const char*，该指针指向一个以null结尾的字符数组，并且确保不会抛出任何异常。

类exception、bad_cast和bad_alloc定义了默认构造函数。类runtime_error和logic_error没有默认构造函数，但是有一个可以接受C风格字符串或者标准库string类型实参的构造函数，这些实参负责提供关于错误的更多信息。在这些类中，what负责返回用于初始化异常对象的信息。因为what是虚函数，所以当我们捕获基类的引用时，对what函数的调用将执行与异常对象动态类型对应的版本。

实际的应用程序通常会自定义exception(或者exception的标准库派生类)的派生类以扩展其继承体系。这些面向应用的异常类表示了与应用相关的异常条件。和其它继承体系一样，异常类也可以看作按照层次关系组织的。层次越低，表示的异常情况就越特殊。例如，在异常类继承体系中位于最顶层的通常是exception，exception表示的含义是某处出错了，至于错误的细节则未作描述。

继承体系的第二层将exception划分为两个大的类别：运行时错误和逻辑错误。运行时错误表示的是只有在程序运行时才能检测到的错误；而逻辑错误一般指的是我们可以在程序代码中发现的错误。

下面是从其他文章中copy的std::exception测试代码，详细内容介绍可以参考对应的reference:

#include "runtime_error.hpp"
#include <iostream>
#include <stdexcept>
#include <string>
 
namespace runtime_error_ {
//
// reference: https://msdn.microsoft.com/en-us/library/tyahh3a9.aspx
int test_runtime_error_1()
{
	try {
		std::locale loc("test");
	} catch (std::exception& e) {
		std::cerr << "Caught " << e.what() << std::endl; // Caught bad locale name
		std::cerr << "Type " << typeid(e).name() << std::endl; // Type class std::runtime_error
	};
 
	return 0;
}
 
/
// reference: http://www.java2s.com/Tutorial/Cpp/0120__Exceptions/Throwyourownexceptionclassbasedonruntimeerror.htm
class DivideByZeroException : public std::runtime_error {
public:
	DivideByZeroException::DivideByZeroException() : runtime_error("attempted to divide by zero") {}
};
 
static double quotient(int numerator, int denominator)
{
	throw DivideByZeroException(); // terminate function
	return 0;
}
 
int test_runtime_error_2()
{
	try {
		double result = quotient(1, 1);
		std::cout << "The quotient is: " << result << std::endl;
	} catch (DivideByZeroException& divideByZeroException) {
		std::cout << "Exception occurred: " << divideByZeroException.what() << std::endl; // Exception occurred: attempted to divide by zero
	}
 
	return 0;
}
 
 
class CppBase_RunTime_Exception : public std::runtime_error {
public :
	CppBase_RunTime_Exception(int error_code_) : runtime_error(""), error_code(error_code_) {}
	CppBase_RunTime_Exception(int error_code_, const std::string& info_) : runtime_error(info_), error_code(error_code_) {}
	int get_error_code() const { return error_code; }
private:
	int error_code = 0;
};
 
static int calc(int a)
{
	if (a > 0) {
		throw CppBase_RunTime_Exception(1, __FUNCTION__);
	}
 
	if (a < 0) {
		throw CppBase_RunTime_Exception(-1, __FUNCTION__);
	}
 
	throw CppBase_RunTime_Exception(0);
 
	return 0;
}
 
int test_runtime_error_3()
{
	const int a{ 2 }, b{ -3 }, c{ 0 };
 
	try {
		calc(a);
	} catch (const CppBase_RunTime_Exception& e) {
		std::cerr << "error fun name: " << e.what() << ", error code: " << e.get_error_code() << std::endl;
	}
 
	try {
		calc(b);
	} catch (const CppBase_RunTime_Exception& e) {
		std::cerr << "error fun name: " << e.what() << ", error code: " << e.get_error_code() << std::endl;
	}
 
	try {
		calc(c);
	} catch (const CppBase_RunTime_Exception& e) {
		std::cerr << "error fun name: " << e.what() << ", error code: " << e.get_error_code() << std::endl;
	}
 
	std::cout << "over" << std::endl;
 
	return 0;
}
 
} // namespace runtime_error_
1
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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

GitHub： https://github.com/fengbingchun/Messy_Test
————————————————
版权声明：本文为CSDN博主「fengbingchun」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/fengbingchun/article/details/78306461/