noexcept 说明符 (C++11 起)

指定函数是否抛出异常。

语法

解释

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

C++ 中的每个函数，或为不抛出，或为潜在抛出。

• 潜在抛出的函数是：

• 声明带有 表达式 求值为 false 的 noexcept 说明符的函数
• 声明不带有 noexcept 声明的函数，除了

• 析构函数，除非有任何潜在构造的基类或成员的析构函数为潜在抛出（见下文）
• 隐式声明的或在其个首声明被预置的默认构造函数、复制构造函数、移动构造函数，除非

• 由构造函数的隐式定义所调用的某个基类或成员的构造函数为潜在抛出（见下文）
• 这种初始化的某个子表达式，例如默认实参表达式，为潜在抛出（见下文）
• 默认成员初始化器（仅对默认构造函数）为潜在抛出（见下文）

• 隐式声明的或在其首个声明被预置的复制赋值运算符、移动赋值运算符，除非隐式定义中对任何赋值运算符的调用为潜在抛出（见下文）

• 解分配函数

• 不抛出函数为所有其他函数（以 表达式 求值为 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
}

template<class T> T f() noexcept(sizeof(T) < 4);
int main() {
    decltype(f<void>()) *p; // f 不求值，但需要 noexcept 说明
                            // 错误，因为实例化 noexcept 说明的实例化要计算 sizeof(void)
}

潜在抛出表达式的正式定义（用于确定上述析构函数、构造函数和赋值运算符的缺省异常说明）是：

以下情况下，表达式 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++ 标准。

参阅