动态异常规定

 

C++

语言

头文件

库概念

语言支持库

诊断库

工具库

字符串库

容器库

算法库

迭代器库

数值库

输入/输出库

本地化库

正则表达式库 (C++11)

原子操作库 (C++11)

线程支持库 (C++11)

文件系统库 (C++17)

技术规范

 

C++ 语言

 

异常

throw 表达式

函数 try 块

try/catch 块

noexcept 指定符(C++11)

noexcept 运算符(C++11)

动态异常规定(弃用)

 

列出函数可能直接或间接抛出的异常。

语法

throw( )	(1)	(C++11 中弃用)
throw(typeid, typeid, ...)	(2)	(C++11 中弃用)(C++17 前)

1) 不抛出动态异常规定	(C++17 前)
1) 与 noexcept(true) 相同	(C++17 起)

2) 显式动态异常规定

此规定仅可出现在作为类型为函数类型、指向函数的指针类型、到函数的引用类型、指向成员函数的指针类型的函数、变量、非静态数据成员的声明器的，顶层 (C++17 前) lambda 声明器或函数声明器上。它可以出现在参数的声明器或返回类型的声明器上。

void f() throw(int); // OK ：函数声明
void (*fp)() throw (int); // OK :指向函数的指针声明
void g(void pfa() throw(int)); // OK ：指向函数指针参数声明
typedef int (*pf)() throw(int); // 错误： typedef 声明

解释

若函数声明带有列于其异常规定的类型 T ，则函数可能抛出该类型或从该类型导出的类型的异常。

不完整类型、指针或到异于 cv void* 的不完整类型引用，及右值引用类型在异常规定中不允许。若使用数组和函数类型，则它们被调整到对应的指针类型。允许参数包。 (C++11 起)

若函数抛出不列于其异常规定的类型的异常，则调用函数 std::unexpected 。函数默认调用 std::terminate ，但它可以为可能调用 std::terminate 或抛出异常的用户提供函数（通过 std::set_unexpected ）替换。若从 std::unexpected 抛出的异常为异常规定所接受，则栈回溯照常持续。若它不被接受，但异常规定允许 std::bad_exception ，则抛出 std::bad_exception 。否则，调用 std::terminate 。

潜在异常 每个函数 f ，指向函数的指针 fp ，与指向成员函数的指针 mfp 拥有一个“潜在异常集合”，它由可能抛出的类型构成。所有类型的集合指示可能抛出所有异常。此集合定义如下： 1) 若 f 、 fp 或 mfp 的声明使用 throw()(弃用) 或 noexcept ，则集合为空。 2) 否则，若 f 、 fp 或 mfp 使用动态异常规定(弃用)，则集合由列于该规定的所有类型组成 3) 否则，集合是所有类型的集合 注意：对于隐式声明的特殊成员函数（构造函数、赋值运算符及析构函数），及对于继承的构造函数，潜在异常的集合是它们会调用的所有函数的潜在异常集合的并集：非变体非静态数据成员、直接基类及适当场合的虚基类的构造函数/赋值运算符/析构函数（还包括默认参数表达式） 每个表达式 e 拥有潜在异常集合，定义如下： 1) 若 e 是一个 核心常量表达式，则集合为空 2) 否则，集合是所有 e 的立即子表达式（包含默认参数表达式）的潜在异常集合的并集，与如下的依赖于 e 的形式其他集合的并： 1) 若 e 是一个函数调用表达式，且 函数以 id 表达式指名（直接或作为成员访问一部分或作为指向成员指针表达式），则将该具名函数的潜在异常集合添加到列表。 若函数以 noexcept 函数类型的表达式指名，或以指向 noexcept 函数的指针类型的表达式指名，则该集合为空 否则，该集合是所有类型的集合 2) 若 e 隐式调用函数（是运算符表达式且该运算符被重载，是 new 表达式且重载了其分配函数，或是完整表达式且调用了临时量的析构函数），则该集合是该函数的集合。 3) 若 e 是一个 throw 表达式，则该集合是将以其运算数初始化的异常，或对于重抛出表达式（无运算数者）是所有异常的集合 4) 若 e 是对到多态类型引用的 dynamic_cast ，则该集合由 std::bad_cast 组成 5) 若 e 是应用到多态泛左值的 typeid ，则该集合由 std::bad_typeid 组成 6) 若 e 是一个拥有非常量大小的 new 表达式，则集合由 std::bad_array_new_length 组成 void f() throw(int); // f() 的集合是“ int ” void g(); // g() 的集合是所有类型的集合 struct A { A(); }; // “ new A ”的集合是所有类型的集合 struct B { B() noexcept; }; // “ B() ”的集合为空 struct D() { D() throw (double); }; // “ new D ”的集合是所有类型的集合 所有隐式声明的成员函数（及继承的构造函数）拥有异常规定，选择如下： 若潜在异常为类型的全集，则隐式异常规定为 noexcept(false) 。 否则，若潜在异常的集合非空，则隐式异常规定列出每个来自该集合的类型 否则，隐式异常规定为 noexcept(true) 且函数是“ noexcept 函数” struct A { A(int = (A(5), 0)) noexcept; A(const A&) throw(); A(A&&) throw(); ~A() throw(X); }; struct B { B() throw(); B(const B&) = default; // 异常规定是“ noexcept(true) ” B(B&&, int = (throw Y(), 0)) noexcept; ~B() throw(Y); }; int n = 7; struct D : public A, public B { int * p = new (std::nothrow) int[n]; // D 拥有下列隐式声明的成员： // D::D() throw(X, std::bad_array_new_length); // D::D(const D&) noexcept(true); // D::D(D&&) throw(Y); // D::~D() throw(X, Y); };

(C++17 起)

示例

运行此代码

#include <iostream>
#include <exception>
#include <cstdlib>
 
class X {};
class Y {};
class Z : public X {};
class W {};
 
void f() throw(X, Y) 
{
    int n = 0;
    if (n) throw X(); // OK
    if (n) throw Z(); // 亦 OK
    throw W(); // 将调用 std::unexpected()
}
 
int main() {
  std::set_unexpected([]{
      std::cout << "That was unexpected" << std::endl; // 需要冲入
      std::abort();
  });
  f();
}

输出：

That was unexpected

参阅

• noexcept 指定符