一、noexcept说明符

1、语法

（1）noexcept

与 noexcept(true) 相同

（2）noexcept（表达式）

如果表达式求值为 true，那么声明函数不会抛出任何异常。

（3）throw() //c++17中弃用 c++20移除

与 noexcept(true) 相同（C++17 ）

2、解释

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

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

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
}

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

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

在需要但尚未实例化某个函数模板特化的 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++17 前)
对有可能会抛出的函数进行隐式调用（例如作为重载运算符，new 表达式中的分配函数，函数实参的构造函数，或当为完整表达式时的析构函数）
是 throw 表达式
是对多态引用类型进行转型的 dynamic_cast
是应用于指向多态类型的指针的解引用的 typeid 表达式
包含有可能会抛出的直接子表达式

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运算符

noexcept 运算符进行编译时检查，如果表达式不会抛出任何异常则返回 true。

它可用于函数模板的 noexcept 说明符中，以声明函数将对某些类型抛出异常，但不对其他类型抛出。

#include<iostream>

#include <utility>
#include <vector>

void may_throw();
void no_throw() noexcept;
auto lmay_throw = [] {};
auto lno_throw = []() noexcept {};

class T
{
public:
    ~T() {} // 析构函数妨碍了移动构造函数
           // 复制构造函数不会抛出异常
};

class U
{
public:
    ~U() {} // 析构函数妨碍了移动构造函数
           // 复制构造函数可能会抛出异常
    std::vector<int> v;
};

class V
{
public:
    std::vector<int> v;
};

int main()
{
    T t;
    U u;
    V v;

    std::cout << std::boolalpha
        << "may_throw() 可能会抛出异常吗？" << !noexcept(may_throw()) << '\n'
        << "no_throw() 可能会抛出异常吗？" << !noexcept(no_throw()) << '\n'
        << "lmay_throw() 可能会抛出异常吗？" << !noexcept(lmay_throw()) << '\n'
        << "lno_throw() 可能会抛出异常吗？" << !noexcept(lno_throw()) << '\n'
        << "~T() 可能会抛出异常吗？" << !noexcept(std::declval<T>().~T()) << '\n'
        // 注：以下各项测试也要求 ~T() 不会抛出异常
        // 因为 noexcept 中的表达式会构造并销毁临时量
        << "T(T 右值) 可能会抛出异常吗？" << !noexcept(T(std::declval<T>())) << '\n'
        << "T(T 左值) 可能会抛出异常吗？" << !noexcept(T(t)) << '\n'
        << "U(U 右值) 可能会抛出异常吗？" << !noexcept(U(std::declval<U>())) << '\n'
        << "U(U 左值) 可能会抛出异常吗？" << !noexcept(U(u)) << '\n'
        << "V(V 右值) 可能会抛出异常吗？" << !noexcept(V(std::declval<V>())) << '\n'
        << "V(V 左值) 可能会抛出异常吗？" << !noexcept(V(v)) << '\n';
}