【C/C++】C++中noexcept的妙用与性能提升

文章目录

C++中noexcept的妙用与性能提升
- [1 什么情况下会抛出异常](#1 什么情况下会抛出异常)
- [2 标记noexcept作用](#2 标记noexcept作用)
- [3 何时使用`noexcept`](#3 何时使用noexcept)
- [4 无异常行为标记场景](#4 无异常行为标记场景)
- [5 一句话总结](#5 一句话总结)

C++中noexcept的妙用与性能提升

在C++中，noexcept修饰符用于指示函数不会抛出异常

1 什么情况下会抛出异常

在 C++ 中，异常（Exception）是程序在运行时遇到错误或意外情况时的一种错误处理机制。

显式抛出异常（throw 关键字）
通过 throw 手动抛出异常，可以是标准库异常类型或自定义类型：

cpp 复制代码

#include <stdexcept>

void validate(int value) {
    if (value < 0) {
        throw std::invalid_argument("Value cannot be negative!");
    }
}

int main() {
    try {
        validate(-5);
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl; // 输出错误信息
    }
}

标准库函数抛出的异常
C++ 标准库中的许多操作在失败时会抛出预定义的异常类型：

内存分配失败

new 在内存不足时抛出 std::bad_alloc：

cpp 复制代码

try {
    int* arr = new int[1000000000000]; // 尝试分配超大内存
} catch (const std::bad_alloc& e) {
    std::cerr << "Memory allocation failed: " << e.what() << std::endl;
}

容器越界访问

std::vector::at() 在索引越界时抛出 std::out_of_range：

cpp 复制代码

std::vector<int> vec = {1, 2, 3};
try {
    int val = vec.at(10); // 越界访问
} catch (const std::out_of_range& e) {
    std::cerr << "Out of range: " << e.what() << std::endl;
}

类型转换失败

dynamic_cast 在向下转型失败时（对引用类型）抛出 std::bad_cast：

cpp 复制代码

class Base { virtual void foo() {} };
class Derived : public Base {};

Base base;
try {
    Derived& d = dynamic_cast<Derived&>(base); // 转型失败（引用类型）
} catch (const std::bad_cast& e) {
    std::cerr << "Bad cast: " << e.what() << std::endl;
}

标准库中的其他异常

数学运算错误 ：如 std::overflow_error、std::underflow_error（需手动检查或使用特定函数）。
文件操作失败 ：std::ifstream 或 std::ofstream 在文件无法打开时可能抛出异常（需启用异常标志）：

cpp 复制代码

std::ifstream file;
file.exceptions(std::ifstream::failbit); // 启用异常
try {
    file.open("nonexistent.txt");
} catch (const std::ios_base::failure& e) {
    std::cerr << "File error: " << e.what() << std::endl;
}

动态类型信息异常

使用 typeid 操作符时，若操作数为空指针（nullptr），可能抛出 std::bad_typeid：

cpp 复制代码

class MyClass { virtual ~MyClass() {} };
MyClass* ptr = nullptr;

try {
    std::cout << typeid(*ptr).name() << std::endl; // 解引用空指针
} catch (const std::bad_typeid& e) {
    std::cerr << "Bad typeid: " << e.what() << std::endl;
}

线程和并发相关异常

若 std::thread 的析构函数被调用时，线程仍在运行且未被 join() 或 detach()，程序会终止（通过 std::terminate）：

cpp 复制代码

#include <thread>

void thread_func() { /* ... */ }

int main() {
    std::thread t(thread_func);
    // 未调用 t.join() 或 t.detach() 直接退出作用域 -> 触发 std::terminate
}

自定义异常
可以继承 std::exception 或其派生类定义自己的异常类型：

cpp 复制代码

#include <exception>

class MyException : public std::runtime_error {
public:
    MyException(const std::string& msg) : std::runtime_error(msg) {}
};

void process() {
    throw MyException("Custom error occurred!");
}

int main() {
    try {
        process();
    } catch (const MyException& e) {
        std::cerr << "Custom error: " << e.what() << std::endl;
    }
}

异常安全注意事项

资源泄漏风险 ：若在异常抛出前未正确释放资源（如内存、文件句柄），可能导致泄漏。应使用 RAII （如智能指针、std::lock_guard）确保资源自动释放。
移动和拷贝操作 ：若对象的移动构造函数可能抛出异常，标准库容器可能回退到拷贝操作（参考 noexcept 优化）。

常见误区

dynamic_cast 对指针和引用的不同行为：
- 对指针类型失败时返回 nullptr，不抛出异常。
- 对引用类型失败时抛出 std::bad_cast。
noexcept 函数中的异常：
- 若 noexcept 函数内部抛出异常，程序直接终止（调用 std::terminate）。

结合上述异常情景，可以总结出：C++ 中的异常通常由以下情况触发：

显式 throw 语句。
标准库函数在特定错误条件下抛出异常（如内存不足、越界访问）。
动态类型转换失败（对引用类型）。
自定义异常类的抛出。

最佳实践：

优先使用标准库异常类型（如 std::runtime_error）。
确保异常安全（通过 RAII 管理资源）。
谨慎使用 noexcept，仅在确定函数不抛异常时使用。

2 标记noexcept作用

性能优化

减少异常处理开销 ：编译器在生成代码时，若函数标记为noexcept，可以省略异常处理的相关机制（如栈展开代码），从而减少生成代码的体积并提升运行效率。
移动语义优化 ：标准库容器（如std::vector）在重新分配内存时，若元素的移动操作（如移动构造函数）被标记为noexcept，则优先使用移动而非拷贝。例如：
cpp 复制代码
```
class MyClass {
public:
    MyClass(MyClass&& other) noexcept { /* ... */ } // 移动构造函数标记为noexcept
};
```
此时，std::vector<MyClass>在扩容时会高效地移动元素而非拷贝。

标准库行为控制

容器操作的异常安全 ：标准库的某些操作（如std::vector::push_back）会根据类型是否支持noexcept移动来决定使用移动还是拷贝。若移动操作可能抛出异常（未标记noexcept），为保障异常安全，标准库会回退到拷贝操作。

接口明确性

契约式设计 ：noexcept作为函数签名的一部分，明确告知调用者该函数不会抛出异常，增强代码可读性和可靠性。例如：
cpp 复制代码
```
void safe_operation() noexcept; // 明确承诺不抛异常
```

错误处理约束

强制终止异常传播 ：若noexcept函数内部抛出异常，程序会直接调用std::terminate()终止，避免异常传播导致未定义行为。例如：
cpp 复制代码
```
void risky() noexcept {
    throw std::runtime_error("oops"); // 触发程序终止
}
```
开发者需确保noexcept函数确实不会抛出异常。

虚函数与继承

异常规范一致性 ：派生类重写的虚函数必须与基类的异常说明兼容。若基类虚函数为noexcept，派生类版本也需标记noexcept：
cpp 复制代码
```
class Base {
public:
    virtual void func() noexcept {}
};
class Derived : public Base {
public:
    void func() noexcept override {} // 必须同样标记noexcept
};
```

条件性noexcept

动态异常说明 ：通过noexcept(condition)根据编译期条件决定是否禁止异常：

cpp 复制代码

template<typename T>
void swap(T& a, T& b) noexcept(noexcept(T(std::move(a))) && noexcept(a.operator=(std::move(b)))) {
    // 当T的移动构造和移动赋值为noexcept时，swap才为noexcept
}

3 何时使用`noexcept`

移动构造函数/赋值运算符（标准库优化的关键）。
简单函数（如getter、资源释放函数）。
标准库要求或可显著提升性能的场景。
注意事项
- 谨慎使用 ：错误标记noexcept可能导致程序意外终止。
- 析构函数 ：默认隐式noexcept，若需允许析构函数抛出异常，需显式标记noexcept(false)（但通常不推荐）。

4 无异常行为标记场景

红黑树代码片段

cpp 复制代码

		// 此函数确实不抛异常，标记 `noexcept` 是安全的。
    static _Const_Base_ptr
    _S_minimum(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPT
    {
      while (__x->_M_left != 0) __x = __x->_M_left;
      return __x;
    }

无显式 throw：函数体无手动抛出异常。
无潜在异常操作 ：
- __x->_M_left 解引用指针，但 _M_left 是内置指针类型（非可能抛异常的智能指针或重载 operator->）。
- 指针比较（__x->_M_left != 0）和赋值（__x = __x->_M_left）均为基本操作，不会抛出异常。
循环终止性：只要树结构合法（左子树有限），循环必然终止，无无限循环风险。

在C++中，即使一个函数本身没有显式抛出异常或调用可能抛出异常的操作，标记为 noexcept 仍然可能出于以下原因：

标准库内部的性能优化要求
标准库的某些操作（如容器扩容、节点调整）会根据成员函数是否 noexcept 选择优化策略：

移动语义优化 ：若函数（如移动构造函数）标记为 noexcept，标准库会优先使用移动而非拷贝，避免潜在的性能损失。
异常安全性保证：标准库需要确保在调整数据结构时，基本操作（如节点查找）不会抛出异常，从而避免破坏容器的不变量（invariants）。

例如，std::vector 在扩容时，若元素类型的移动操作是 noexcept，则使用移动；否则回退到拷贝。类似地，此处的 _S_minimum 若被标记为 noexcept，可能允许上层操作（如树的重新平衡）安全地依赖它。

编译器优化
标记为 noexcept 的函数会触发编译器的优化机制：

省略异常处理代码：编译器无需生成栈展开（stack unwinding）逻辑，减少生成的机器码体积，提升运行效率。
内联可能性 ：简单的 noexcept 函数更易被内联，进一步减少调用开销。

此函数仅遍历左子节点，逻辑简单且无复杂操作，标记 noexcept 后可能被编译器深度优化。

接口契约与代码规范

明确承诺不抛异常 ：即使当前实现无异常，标记 noexcept 是对调用者的严格约定，表明开发者保证未来修改也不会引入异常。
代码可维护性：强制后续维护者遵守不抛异常的约束，若误添加可能抛异常的操作，编译器会报错。

适配模板元编程需求
此函数可能是模板或泛型代码的一部分，某些模板可能要求传入的操作是 noexcept 的。例如：

cpp 复制代码

template<typename Func>
void process(Func f) noexcept(noexcept(f())) {
    // 若 f() 为 noexcept，则 process 也为 noexcept
    f();
}

若 _S_minimum 被此类模板使用，则需明确标记 noexcept 以满足编译期条件。

标准库实现惯例
在标准库（如 libstdc++）的实现中，底层工具函数通常默认标记为 noexcept，除非明确可能抛异常。这是为了：

统一代码风格：保持内部函数异常说明的一致性。
防御性编程 ：避免因未预料的操作（如自定义类型的 operator-> 重载抛出异常）导致问题。但此例中 __x->_M_left 是内置指针操作，无重载风险，故安全。

汇总
此函数标记 noexcept 的主要原因包括：
1. 标准库优化：允许依赖它的上层操作（如容器调整）选择高效路径。
2. 编译器优化：减少异常处理开销，提升性能。
3. 接口契约：明确承诺不抛异常，增强代码可靠性。
4. 代码规范：遵循标准库内部实现惯例。

即使函数本身无显式异常，noexcept 在底层代码中仍是关键优化和设计手段。

5 一句话总结

noexcept通过指导编译器和标准库优化，提升程序性能与可靠性，但需在充分确保函数无异常抛出的前提下使用。

【C/C++】C++中noexcept的妙用与性能提升

文章目录

C++中noexcept的妙用与性能提升

1 什么情况下会抛出异常

2 标记noexcept作用

3 何时使用noexcept

4 无异常行为标记场景

5 一句话总结

3 何时使用`noexcept`