noexcept异常说明

 

noexcept异常使用

 
相比于断言适用于排除逻辑上不可能存在的状态，异常通常是用于逻辑上可能发生的错误。在C++98中，我们看到了一套完整的不同于C的异常处理系统。通过这套异常处理系统，C++拥有了远比C强大的异常处理功能。

在异常处理的代码中，程序员有可能看到过如下的异常声明表达形式：
[cpp] view plain copy
 
  1. void excpt_func() throw(int, double) { ... }  
 
在excpt_func函数声明之后，我们定义了一个动态异常声明throw(int, double)，该声明指出了excpt_func可能抛出的异常的类型。事实上，该特性很少被使用，因此在C++11中被弃用了（参见附录B），而表示函数不会抛出异常的动态异常声明throw()也被新的noexcept异常声明所取代。

noexcept形如其名地，表示其修饰的函数不会抛出异常。不过与throw()动态异常声明不同的是，在C++11中如果noexcept修饰的函数抛出了异常，编译器可以选择直接调用std::terminate()函数来终止程序的运行，这比基于异常机制的throw()在效率上会高一些。这是因为异常机制会带来一些额外开销，比如函数抛出异常，会导致函数栈被依次地展开（unwind），并依帧调用在本帧中已构造的自动变量的析构函数等。

从语法上讲，noexcept修饰符有两种形式，一种就是简单地在函数声明后加上noexcept关键字。比如：
 
[cpp] view plain copy
 
  1. void excpt_func() noexcept;  

另外一种则可以接受一个常量表达式作为参数，如下所示：
[cpp] view plain copy
 
  1. void excpt_func() noexcept (常量表达式);  

常量表达式的结果会被转换成一个bool类型的值。该值为true，表示函数不会抛出异常，反之，则有可能抛出异常。这里，不带常量表达式的noexcept相当于声明了noexcept(true)，即不会抛出异常。

在通常情况下，在C++11中使用noexcept可以有效地阻止异常的传播与扩散。我们可以看看下面这个例子，如代码清单2-12所示。
 
[cpp] view plain copy
 
  1. #include <iostream>  
  2. using namespace std;  
  3. void Throw() { throw 1; }  
  4. void NoBlockThrow() { Throw(); }  
  5. void BlockThrow() noexcept { Throw(); }  
  6.   
  7. int main() {  
  8.     try {  
  9.         Throw();  
  10.     }  
  11.     catch(...) {  
  12.         cout << "Found throw." << endl;     // Found throw.  
  13.     }  
  14.   
  15.     try {  
  16.         NoBlockThrow();  
  17.     }  
  18.     catch(...) {  
  19.         cout << "Throw is not blocked." << endl;    // Throw is not blocked.  
  20.     }  
  21.   
  22.     try {  
  23.         BlockThrow();   // terminate called after throwing an instance of 'int'  
  24.     }  
  25.     catch(...) {  
  26.         cout << "Found throw 1." << endl;  
  27.     }  
  28. }  

在上述程序中，我们定义了Throw函数，该函数的唯一作用是抛出一个异常。而NoBlockThrow是一个调用Throw的普通函数，BlockThrow则是一个noexcept修饰的函数。从main的运行中我们可以看到，NoBlockThrow会让Throw函数抛出的异常继续抛出，直到main中的catch语句将其捕捉。而BlockThrow则会直接调用std::terminate中断程序的执行，从而阻止了异常的继续传播。从使用效果上看，这与C++98中的throw()是一样的。

而noexcept作为一个操作符时，通常可以用于模板。比如：
[cpp] view plain copy
 
  1. template <class T>  
  2. void fun() noexcept(noexcept(T())) {}  

这里，fun函数是否是一个noexcept的函数，将由T()表达式是否会抛出异常所决定。这里的第二个noexcept就是一个noexcept操作符。当其参数是一个有可能抛出异常的表达式的时候，其返回值为false，反之为true（实际noexcept参数返回false还包括一些情况，这里就不展开讲了）。这样一来，我们就可以使模板函数根据条件实现noexcept修饰的版本或无noexcept修饰的版本。从泛型编程的角度看来，这样的设计保证了关于“函数是否抛出异常”这样的问题可以通过表达式进行推导。因此这也可以视作C++11为了更好地支持泛型编程而引入的特性。

虽然noexcept修饰的函数通过std::terminate的调用来结束程序的执行的方式可能会带来很多问题，比如无法保证对象的析构函数的正常调用，无法保证栈的自动释放等，但很多时候，“暴力”地终止整个程序确实是很简单有效的做法。事实上，noexcept被广泛地、系统地应用在C++11的标准库中，用于提高标准库的性能，以及满足一些阻止异常扩散的需求。

比如在C++98中，存在着使用throw()来声明不抛出异常的函数

[cpp] view plain copy
 
  1. template<class T> class A {  
  2. public:  
  3. static constexpr T min() throw() { return T(); }  
  4. static constexpr T max() throw() { return T(); }  
  5. static constexpr T lowest() throw() { return T(); }  
  6. ...  

而在C++11中，则使用noexcept来替换throw()。

[cpp] view plain copy
 
  1. template<class T> class A {  
  2. public:  
  3. static constexpr T min() noexcept { return T(); }  
  4. static constexpr T max() noexcept { return T(); }  
  5. static constexpr T lowest() noexcept { return T(); }  
  6. ...  

又比如，在C++98中，new可能会包含一些抛出的std::bad_alloc异常。

[cpp] view plain copy
 
  1. void* operator new(std::size_t) throw(std::bad_alloc);  
  2. void* operator new[](std::size_t) throw(std::bad_alloc);  

而在C++11中，则使用noexcept(false)来进行替代。

[cpp] view plain copy
 
  1. void* operator new(std::size_t) noexcept(false);  
  2. void* operator new[](std::size_t) noexcept(false);  

当然，noexcept更大的作用是保证应用程序的安全。比如一个类析构函数不应该抛出异常，那么对于常被析构函数调用的delete函数来说，C++11默认将delete函数设置成noexcept，就可以提高应用程序的安全性。
[cpp] view plain copy
 
  1. void operator delete(void*) noexcept;  
  2. void operator delete[](void*) noexcept;  

而同样出于安全考虑，C++11标准中让类的析构函数默认也是noexcept(true)的。当然，如果程序员显式地为析构函数指定了noexcept，或者类的基类或成员有noexcept(false)的析构函数，析构函数就不会再保持默认值。我们可以看看下面的例子：

[cpp] view plain copy
 
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. struct A {  
  5.     ~A() { throw 1; }  
  6. };  
  7.   
  8. struct B {  
  9.     ~B() noexcept(false) { throw 2; }  
  10. };  
  11.   
  12. struct C {  
  13.     B b;  
  14. };  
  15.   
  16. int funA() { A a; }  
  17. int funB() { B b; }  
  18. int funC() { C c; }  
  19.   
  20. int main() {  
  21.     try {  
  22.         funB();  
  23.     }  
  24.     catch(...){  
  25.         cout << "caught funB." << endl; // caught funB.  
  26.     }  
  27.   
  28.     try {  
  29.         funC();  
  30.     }  
  31.     catch(...){  
  32.         cout << "caught funC." << endl; // caught funC.  
  33.     }  
  34.   
  35.     try {  
  36.         funA(); // terminate called after throwing an instance of 'int'  
  37.     }  
  38.     catch(...){  
  39.         cout << "caught funA." << endl;  
  40.     }  
  41. }  

在代码中，无论是析构函数声明为noexcept(false)的类B，还是包含了B类型成员的类C，其析构函数都是可以抛出异常的。只有什么都没有声明的类A，其析构函数被默认为noexcept(true)，从而阻止了异常的扩散。这在实际的使用中，应该引起程序员的注意
posted on 2017-06-16 15:12  非宁静，无以致远  阅读(1211)  评论(0)    收藏  举报
博客园  ©  2004-2026
浙公网安备 33010602011771号 浙ICP备2021040463号-3