C++ --- noexcept关键字 明确函数不抛出任何异常

在C++11标准中引入的noexcept关键字，是异常安全设计与编译器优化的核心特性。它通过显式声明函数"是否可能抛出异常"，为开发者提供了异常安全的契约机制，也为编译器生成高效代码提供了关键依据。

一、noexcept的引入背景

在C++11之前，C++依赖动态异常规范 （如throw(int, double)）声明函数的异常抛出行为，但该机制存在三大缺陷：

1. 运行时开销大 ：动态异常规范需要运行时检查，若抛出未声明的异常，会调用std::unexpected()终止程序，增加性能负担；
2. 编译器优化受限：动态异常规范仅为"提示"，编译器无法确定函数是否真的不抛出异常，难以进行针对性优化；
3. 表达能力弱 ：无法基于上下文（如模板参数）动态决定异常行为，且throw()（声明不抛出任何异常）的语义与实际行为存在偏差（C++98中throw()函数若抛出异常，会调用std::unexpected()而非直接终止）。

为解决这些问题，C++11废弃了动态异常规范（C++17完全移除），引入noexcept关键字，其核心目标是：

• 提供编译期可验证的异常契约，明确函数"不抛出异常"的承诺；
• 减少运行时开销，允许编译器进行激进优化；
• 支持条件性异常声明（如基于模板参数动态决定是否noexcept）；
• 与标准库深度协同（如容器的移动操作效率依赖noexcept）。

二、noexcept的基本语法与语义

2.1 语法形式

noexcept有两种核心语法形式，均用于修饰函数（含构造/析构/运算符重载/模板函数）：

（1）无条件声明

// 形式1：等价于noexcept(true)，明确函数不抛出任何异常
void func() noexcept;
// 形式2：显式指定为noexcept(false)，函数可能抛出异常（通常省略，默认行为）
void func() noexcept(false);

• 注：未显式声明noexcept的函数，默认等价于noexcept(false)（即"可能抛出异常"）；
• 特殊情况：析构函数、operator delete、operator delete[]默认隐式声明为noexcept(true)（C++11及以后），除非类的成员/基类的析构函数是noexcept(false)。

（2）条件声明（noexcept(表达式)）

// 表达式必须是编译期可求值的bool常量表达式，结果决定函数是否noexcept
template <typename T>
void swap(T& a, T& b) noexcept(noexcept(T(std::move(a)))) {
    T temp = std::move(a);
    a = std::move(b);
    b = std::move(temp);
}

• 内层noexcept(表达式)是noexcept运算符 ，用于判断"表达式在执行时是否不会抛出异常"，返回bool类型的常量表达式；
• 外层noexcept(...)是异常声明，将运算符的结果作为函数的异常契约。

2.2 核心语义

noexcept的本质是函数对调用者的契约：

• 若函数声明为noexcept(true)（或noexcept），则承诺"在任何情况下都不会抛出异常"（包括直接抛出、间接调用抛出异常的函数、析构函数抛出等）；
• 若违反契约（即noexcept函数实际抛出了异常），C++标准规定直接调用std::terminate()终止程序，且不保证栈展开（stack unwinding），可能导致资源泄漏；
• noexcept不影响函数的调用逻辑，仅为编译器提供优化依据和异常安全提示（编译器不会强制检查函数内部是否真的不抛出异常，需开发者自行保证）。

2.3 与throw()的区别（关键兼容性点）

C++98的throw()（空动态异常规范）在C++11中被弃用，C++17中完全移除，其与noexcept的核心差异如下：

特性	throw()（C++98）	noexcept（C++11+）
语义	承诺不抛出异常，违反则调用std::unexpected()	承诺不抛出异常，违反则调用std::terminate()
运行时开销	有（需维护异常规范检查）	无（编译期确定，无额外检查）
编译器优化支持	弱	强（可省略栈展开代码）
条件性声明支持	不支持	支持（noexcept(表达式)）
析构函数默认行为	无默认声明	默认noexcept(true)
兼容性	C++17移除（仅throw()等价于noexcept）	长期支持，为标准推荐用法

结论 ：永远不要使用throw()，优先使用noexcept。

三、noexcept的核心应用场景

3.1 移动构造/赋值运算符（性能关键）

标准库容器（如std::vector、std::deque）在扩容、插入等操作中，会根据元素的移动操作是否noexcept，选择"移动元素"或"拷贝元素"：

• 若移动构造/赋值是noexcept：容器会直接移动元素（O(1)开销，无拷贝）；
• 若移动构造/赋值不是noexcept：容器会拷贝元素（O(n)开销，避免移动过程中抛出异常导致数据不一致）。

示例：

#include <vector>
#include <utility>

class HeavyObject {
private:
    int* data;
    size_t size;
public:
    // 普通构造函数
    HeavyObject(size_t s) : size(s), data(new int[s]) {}

    // 移动构造函数：声明noexcept，确保容器优先选择移动
    HeavyObject(HeavyObject&& other) noexcept 
        : data(other.data), size(other.size) {
        other.data = nullptr; // 避免源对象析构时释放资源
        other.size = 0;
    }

    // 移动赋值运算符：同样声明noexcept
    HeavyObject& operator=(HeavyObject&& other) noexcept {
        if (this != &other) {
            delete[] data; // 释放当前资源
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }

    // 析构函数：默认noexcept(true)，无需显式声明
    ~HeavyObject() {
        delete[] data;
    }

    // 禁用拷贝（避免默认拷贝构造/赋值干扰）
    HeavyObject(const HeavyObject&) = delete;
    HeavyObject& operator=(const HeavyObject&) = delete;
};

int main() {
    std::vector<HeavyObject> vec;
    vec.reserve(1);
    vec.emplace_back(1000000); // 构造大对象
    vec.resize(2); // 扩容时，因移动构造noexcept，直接移动元素（高效）
    return 0;
}

若移除移动构造的noexcept，vec.resize(2)会触发拷贝构造（低效），甚至可能因无拷贝构造（示例中已禁用）导致编译错误。

3.2 析构函数与资源释放函数

C++11后，析构函数默认隐式声明为noexcept(true)，除非满足以下任一条件：

1. 类的基类析构函数是noexcept(false)；
2. 类的非静态数据成员的析构函数是noexcept(false)；
3. 类的虚基类析构函数是noexcept(false)。

为什么默认noexcept？

析构函数若抛出异常，会导致严重问题：若在栈展开（处理另一个异常时调用析构函数）过程中，析构函数再抛出异常，C++会直接调用std::terminate()终止程序。因此，析构函数必须保证不抛出异常，默认noexcept是强制约束。

特殊情况 ：若确实需要析构函数抛出异常（极不推荐），需显式声明noexcept(false)：

class RiskyClass {
public:
    ~RiskyClass() noexcept(false) {
        throw "Destructor exception"; // 危险！可能导致程序终止
    }
};

3.3 模板函数的条件性noexcept

模板函数的异常行为往往依赖模板参数（如模板参数的移动构造是否noexcept），此时需用noexcept(表达式)实现"条件性异常声明"，让模板函数的noexcept属性随模板参数动态变化。

示例：自定义swap函数

template <typename T>
void my_swap(T& a, T& b) noexcept(
    // 判断T的移动构造和移动赋值是否都noexcept
    noexcept(T(std::move(a))) && 
    noexcept(a = std::move(b))
) {
    T temp = std::move(a); // 若T的移动构造noexcept，此处无异常风险
    a = std::move(b);      // 若T的移动赋值noexcept，此处无异常风险
    b = std::move(temp);
}

• 当T是int、std::string（C++11后移动构造/赋值noexcept）时，my_swap是noexcept(true)；
• 当T是自定义类型且移动操作非noexcept时，my_swap是noexcept(false)。

这种设计与标准库的std::swap保持一致，确保模板函数在不同场景下都能兼顾异常安全和性能。

3.4 异常安全级别与noexcept

C++异常安全分为四个级别（从低到高）：

1. 无保证（No guarantee）：异常抛出后，程序状态不确定；
2. 基本保证（Basic guarantee）：异常抛出后，程序状态有效，但资源可能泄漏；
3. 强保证（Strong guarantee）：异常抛出后，程序状态恢复到操作前（要么完全成功，要么完全不影响）；
4. 不抛出保证（Nothrow guarantee）：函数永远不会抛出异常（noexcept函数的核心目标）。

noexcept函数天然满足"不抛出保证"，是实现高等级异常安全的基础。例如：

• swap函数必须是noexcept：很多强保证的算法（如std::sort）依赖swap的不抛出特性，若swap抛出异常，算法无法回滚到初始状态；
• 资源释放函数（如close、free）：必须noexcept，避免资源释放过程中抛出异常导致泄漏。

3.5 与标准库的协同

标准库的很多函数和容器操作的noexcept属性，直接依赖用户自定义类型的noexcept声明。以下是典型案例：

标准库操作	noexcept条件（简化版）
std::vector::push_back	std::is_nothrow_copy_constructible_v<T>
std::vector::emplace_back	std::is_nothrow_constructible_v<T, Args...>
std::vector::resize	扩容时：std::is_nothrow_move_constructible_v<T>
std::swap	noexcept(swap(a, b))（依赖类型的swap是否noexcept）

例如，std::vector::resize当需要扩容时，若T的移动构造是noexcept，则会移动元素（高效且强异常安全）；否则会拷贝元素（低效但保证安全）。

四、noexcept的高级特性与版本差异

4.1 C++17的关键变化：noexcept成为函数类型的一部分

C++11/14中，noexcept仅为函数的"异常规格"，不属于函数类型的一部分，因此以下代码会编译错误（视为重复定义）：

// C++11/14：编译错误（重复定义）
void func() {}
void func() noexcept {}

C++17中，noexcept正式成为函数类型的一部分，上述代码合法（视为两个不同的函数重载）。同时，函数指针、函数引用的类型也会包含noexcept属性：

#include <type_traits>

void f() noexcept {}
void g() {}

int main() {
    // 函数指针类型不同：void(*)() noexcept vs void(*)()
    static_assert(!std::is_same_v<decltype(&f), decltype(&g)>); 
    void (*p1)() noexcept = &f; // 合法
    // void (*p2)() = &f; // 非法（非noexcept指针不能指向noexcept函数）
    void (*p3)() noexcept = &g; // 合法（noexcept指针可以指向非noexcept函数）
    return 0;
}

规则 ：指向noexcept函数的指针/引用，可以指向非noexcept函数（更严格的契约可以兼容宽松的契约）；反之则不行。

4.2 虚函数与noexcept的兼容性

虚函数的noexcept属性需满足"子类重写函数的异常契约不弱于基类"，即：

• 基类虚函数若为noexcept(true)，子类重写函数必须也是noexcept(true)（或默认，因析构函数外的函数默认noexcept(false)，需显式声明）；
• 基类虚函数若为noexcept(false)，子类重写函数可以是noexcept(false)或noexcept(true)（更严格的契约兼容）。

示例：

class Base {
public:
    virtual void func() noexcept(true) {} // 基类承诺不抛出
    virtual void func2() noexcept(false) {} // 基类允许抛出
};

class Derived : public Base {
public:
    // 合法：重写函数与基类noexcept一致
    void func() noexcept(true) override {} 
    // 非法：重写函数的异常契约弱于基类（基类noexcept(true)，子类noexcept(false)）
    // void func() noexcept(false) override {} 

    // 合法：子类契约更严格（允许抛出→不抛出）
    void func2() noexcept(true) override {} 
};

违反兼容性规则会直接导致编译错误。

4.3 noexcept与constexpr的结合

constexpr函数可以声明为noexcept，只要满足constexpr的编译期求值条件，且函数确实不抛出异常：

// 合法：constexpr + noexcept
constexpr int add(int a, int b) noexcept {
    return a + b;
}

int main() {
    constexpr int x = add(3, 5); // 编译期求值，无异常
    int y = add(3, 5); // 运行时求值，仍noexcept
    return 0;
}

• 若constexpr函数声明为noexcept，但运行时执行路径抛出异常，仍会调用std::terminate()；
• constexpr函数的noexcept属性不影响其编译期求值能力，仅用于异常契约。

4.4 noexcept运算符的细节

noexcept(表达式)是编译期运算符，用于判断"表达式在执行时是否不会抛出任何异常"，其判断逻辑如下：

1. 表达式本身不直接抛出异常（如5+3、std::move(x)）；
2. 表达式调用的所有函数（包括析构函数）都是noexcept(true)；
3. 表达式的操作符（如+、=）不抛出异常；
4. 若表达式是函数调用，函数的异常契约为noexcept(true)。

示例：

#include <utility>

class A {
public:
    A() noexcept {}
    A(A&&) noexcept {}
    A& operator=(A&&) noexcept(false) {}
};

int main() {
    A a, b;
    static_assert(noexcept(A())); // true（默认构造noexcept）
    static_assert(noexcept(A(std::move(a)))); // true（移动构造noexcept）
    static_assert(!noexcept(a = std::move(b))); // false（移动赋值noexcept(false)）
    static_assert(noexcept(5 + 3)); // true（算术运算不抛出）
    static_assert(!noexcept(throw 1)); // false（直接抛出异常）
    return 0;
}

noexcept运算符的结果是bool常量表达式，可用于模板元编程、条件编译等场景。

五、noexcept的常见错误与注意事项

5.1 常见错误用法

（1）滥用noexcept：盲目声明函数为noexcept

若函数内部调用了可能抛出异常的函数（如new、std::vector::push_back），却声明为noexcept，会导致运行时std::terminate()：

// 错误示例：new可能抛出std::bad_alloc，却声明noexcept
void bad_func() noexcept {
    int* p = new int[1000000000000]; // 内存不足时抛出异常，触发std::terminate()
}

（2）遗漏移动操作的noexcept

自定义类型若实现了移动构造/赋值，却未声明noexcept，会导致标准库容器优先选择拷贝操作，性能大幅下降。

（3）析构函数显式声明noexcept(false)

除非有极端特殊需求（几乎不存在），否则析构函数的noexcept(false)会埋下程序终止的隐患。

（4）模板函数未使用条件性noexcept

模板函数若固定声明为noexcept(true)，当模板参数是"可能抛出异常"的类型时，会违反异常契约。

5.2 注意事项

（1）明确需要noexcept的场景

• 移动构造/赋值运算符：优先声明noexcept（除非确实需要抛出异常）；
• swap函数（包括自定义swap和类的成员swap）：必须声明noexcept；
• 析构函数：依赖默认noexcept(true)，无需显式声明；
• 资源释放函数（如close、free）：声明noexcept；
• 简单数学运算、无外部依赖的工具函数：声明noexcept。

（2）谨慎使用noexcept(false)

仅当函数确实需要抛出异常，且调用者必须处理该异常时，才显式声明noexcept(false)（通常省略，因默认即为noexcept(false)）。

（3）模板函数使用条件性noexcept

基于模板参数的特性（如std::is_nothrow_constructible、noexcept运算符）动态决定noexcept，确保模板的通用性和安全性。

（4）结合类型特征验证noexcept

使用<type_traits>中的工具函数验证类型的noexcept属性，避免错误：

#include <type_traits>
#include "HeavyObject.h"

static_assert(std::is_nothrow_move_constructible_v<HeavyObject>);
static_assert(std::is_nothrow_move_assignable_v<HeavyObject>);

（5）避免在noexcept函数中调用非noexcept函数

若必须调用，需通过try-catch捕获所有异常，确保不向外传播：

void safe_func() noexcept {
    try {
        // 调用可能抛出异常的函数
        risky_func();
    } catch (...) {
        // 处理异常（如日志、降级策略），不向外抛出
        log_error("risky_func failed");
    }
}

---

noexcept是C++异常安全与性能优化的核心特性，其核心价值在于"明确异常契约"和"助力编译器优化"。掌握noexcept需抓住以下关键点：

1. 语法上：支持无条件（noexcept）和条件性（noexcept(表达式)）声明；
2. 语义上：noexcept是"不抛出异常"的契约，违反则终止程序；
3. 应用上：移动操作、swap、析构函数是核心场景，模板函数需条件性声明；
4. 版本上：C++17后noexcept成为函数类型一部分，支持重载；
5. 实践上：避免滥用，仅在确定函数不抛出异常时使用，模板函数需动态适配。

正确使用noexcept，既能提升程序性能（减少异常处理开销、启用编译器优化），又能增强代码的异常安全性和可读性