noexcept 说明符 (C++11 起)

来自cppreference.com
< cpp‎ | language
 
C++
 
C++ 语言
 
异常
 

指定函数是否抛出异常。

语法

noexcept (1)
noexcept(表达式) (2)
throw() (3) (C++17 起)
(C++17 中弃用)
(C++20 中移除)
1) 与 noexcept(true) 相同
2) 如果 表达式 求值为 true，那么声明函数不会抛出任何异常。
3) 与 noexcept(true) 相同（C++17 前的语义见动态异常说明）
表达式 - 按语境转换为 bool 类型的常量表达式

解释

noexcept 说明不是函数类型的一部分（正如同动态异常说明），而且只能在声明函数、变量、函数类型的非静态数据成员、函数指针、函数引用或成员函数指针时，以及在以上这些声明中声明类型为函数指针或函数引用的形参或返回类型时，作为 lambda 声明符或顶层函数声明符的一部分出现。它不能在 typedef 或类型别名声明中出现。 

void f() noexcept; // 函数 f() 不会抛出
void (*fp)() noexcept(false); // fp 指向可能会抛出的函数
void g(void pfa() noexcept);  // g 接收指向不会抛出的函数的指针
// typedef int (*pf)() noexcept; // 错误
 (C++17 前)

noexcept 说明是函数类型的一部分，可以作为任何函数声明符的一部分出现。

(C++17 起)

C++ 中的每个函数要么不会抛出，要么有可能会抛出。

  • 有可能会抛出的函数是：
(C++17 前)
  • 声明带有求值为 false 的 表达式 的 noexcept 说明符的函数
  • 声明不带有 noexcept 声明的函数，除了
  • 由构造函数的隐式定义所调用的某个基类或成员的构造函数有可能会抛出（见下文）
  • 这种初始化的某个子表达式，例如默认实参表达式，有可能会抛出（见下文）
  • （默认构造函数的）默认成员初始化器有可能会抛出（见下文）
  • 隐式声明的或在它的首个声明被预置的复制赋值运算符、移动赋值运算符，除非隐式定义中对任何赋值运算符的调用有可能会抛出（见下文）
  • 在它的首个声明被预置的比较运算符，除非它的隐式定义中对任何比较运算符的调用有可能会抛出（见下文）
(C++20 起)
  • 所有其他函数（以求值为 true 的 表达式 的 noexcept 说明符声明的函数，以及析构函数、预置的特殊成员函数和解分配函数）都不会抛出

显式实例化可以使用 noexcept 说明符，但不要求。如果有使用，那么它的异常说明必须与所有其他声明相同。只有在这些异常说明在同一翻译单元中不相同时才要求诊断。

只有异常说明不同的函数不能重载（与返回类型相似，异常说明是函数类型的一部分，但不是函数签名的一部分） (C++17 起)。 

void f() noexcept;
void f(); // 错误：异常说明不同
void g() noexcept(false);
void g(); // OK：g 的两个声明均有可能会抛出

指向不会抛出的函数的指针（包括成员函数指针）能赋值给或用以初始化 (C++17 前)可以隐式转换到 (C++17 起)指向有可能会抛出的函数的指针，但反之不可。 

void ft(); // 有可能会抛出
void (*fn)() noexcept = ft; // 错误

如果虚函数不会抛出，那么它每个覆盖的函数的所有声明（包括定义）都必须不抛出，除非覆盖函数被定义为弃置： 

struct B {
    virtual void f() noexcept;
    virtual void g();
    virtual void h() noexcept = delete;
};
 
struct D: B {
    void f();              // 谬构：D::f 有可能会抛出，B::f 不会抛出
    void g() noexcept;     // OK
    void h() = delete;     // OK
};

不会抛出的函数允许调用有可能会抛出的函数。每当抛出异常且对处理块的查找遇到了不会抛出的函数的最外层块时，就调用函数 std::terminate 或 std::unexpected (C++17 前)： 

extern void f(); // 有可能会抛出
 
void g() noexcept {
    f();      // 合法，即使 f 抛出
    throw 42; // 合法，等效于调用 std::terminate
}

函数模板特化的异常说明不随函数声明而实例化；它只会在需要（定义如下）时实例化。

隐式声明的特殊成员函数的异常说明也只会在需要时求值（特别是，派生类成员函数的隐式声明不要求实例化基类成员函数的异常说明）

在需要但尚未实例化某个函数模板特化的 noexcept 说明时，如同对该特化的声明一样，对待决名进行查找并实例化 表达式 中用到的任何模板。

在下列语境中认为需要函数的 noexcept 说明：

  • 在表达式中，函数被重载决议选中
  • 函数被ODR 使用
  • 函数本该被 ODR 使用但在不求值操作数中出现： 
template<class T> T f() noexcept(sizeof(T) < 4);
 
int main() {
    decltype(f<void>()) *p; // f 不求值，但需要 noexcept 说明
                            // 错误，因为实例化 noexcept 说明的实例化要计算 sizeof(void)
}
  • 该特化需要与另一函数声明进行比较（例如在虚函数覆盖或函数模板的显式特化处）
  • 在函数定义中
  • 需要异常说明，因为某个预置特殊成员函数需要检查它以决定它自身的异常说明（这只会在这个预置特殊成员函数自身的异常说明被需要时发生）。
(C++14 起)


有可能会抛出的表达式的正式定义（用于确定上述析构函数、构造函数和赋值运算符的默认异常说明）是：

以下情况下，表达式 e 有可能会抛出：

  • e 是对有可能会抛出的函数、函数指针或成员函数指针的调用，除非 e 是核心常量表达式 (C++17 前)
  • e 对有可能会抛出的函数进行隐式调用（例如作为重载运算符，new 表达式中的分配函数，函数实参的构造函数，或当 e 为完整表达式时的析构函数）
  • e 是 throw 表达式
  • e 是对多态引用类型进行转型的 dynamic_cast
  • e 是应用于指向多态类型的指针的解引用的 typeid 表达式
  • e 包含有可能会抛出的直接子表达式 
struct A {
    A(int = (A(5), 0)) noexcept;
    A(const A&) noexcept;
    A(A&&) noexcept;
    ~A();
};
 
struct B {
    B() throw();
    B(const B&) = default; // 隐式异常说明是 noexcept(true)
    B(B&&, int = (throw Y(), 0)) noexcept;
    ~B() noexcept(false);
};
 
int n = 7;
struct D : public A, public B {
    int * p = new int[n];
    // D::D() 有可能会抛出，因为 new 运算符
    // D::D(const D&) 不会抛出
    // D::D(D&&) 有可能会抛出：因为 B 的构造函数的默认实参有可能会抛出
    // D::~D() 有可能会抛出
 
    // 注意：如果 A::~A() 为虚，那么此程序将为非良构，因为不会抛出的虚函数的覆盖函数不能抛出
};

注解

常量 表达式 的一种用法（与 noexcept 运算符一起）是，定义函数模板，它对一些类型声明 noexcept，但对其他类型不声明。

注意，函数上的 noexcept 说明不是一种编译时检查；它只不过是程序员告知编译器函数是否可以抛出异常的一种方法。编译器能用此信息启用不会抛出的函数上的某些优化，以及启用能在编译时检查特定表达式是否声明为可抛出任何异常的 noexcept 运算符。例如，诸如 std::vector 的容器会在元素的移动构造函数是 noexcept 的情况下移动元素，否则就复制元素（除非复制构造函数不可访问，但有可能会抛出的移动构造函数只会在放弃强异常保证的情况下考虑）。

弃用

noexcept 是 throw() 的改进版本，后者在 C++11 中弃用。与 C++17 前的 throw() 不同，noexcept 不会调用 std::unexpected，并且可能或可能不进行栈回溯，这可能允许编译器实现没有 throw() 的运行时开销的 noexcept。从 C++17 起，throw() 被重定义为严格等价于 noexcept(true)。

关键词

noexcept

示例

运行此代码
// foo 是否声明为 noexcept 取决于 T() 是否会抛出异常
template <class T>
    void foo() noexcept(noexcept(T())) {}
 
void bar() noexcept(true) {}
void baz() noexcept { throw 42; }  // noexcept 等同于 noexcept(true)
 
int main() 
{
    foo<int>(); // noexcept(noexcept(int())) => noexcept(true)，所以这是可以的
 
    bar(); // 可以
    baz(); // 能编译，但会在运行时调用 std::terminate
}

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

DR 应用于 出版时的行为 正确行为
CWG 2039 C++11 只要求转换前的表达式是常量 转换必须也在常量表达式中合法

参阅

noexcept 运算符(C++11) 确定表达式是否会抛出任何异常
动态异常说明(C++17 前) 指定函数所抛出的异常 (C++11 中弃用)
throw 表达式 引发错误并将控制转移到错误处理块
(C++11)
 若移动构造函数不抛出则获得右值引用
(函数模板)
来自“https://zh.cppreference.com/mwiki/index.php?title=cpp/language/noexcept_spec&oldid=73217”