c++：noexcept关键字解析及应用-优快云博客

本文链接：https://blog.youkuaiyun.com/qqrrjj2011/article/details/145487924

文章目录

noexcept 是 C++11 引入的一个重要关键字，它用于向编译器表明一个函数不会抛出异常。这个信息可以被编译器用来进行某些优化，并且在决定使用哪个重载函数或模板实例化时也能起到作用。

使用方式

基本形式：在函数声明的后面加上 noexcept。
```
void foo() noexcept;
```
可以指定条件表达式：如果表达式为 true，则函数承诺不抛出异常；如果为 false，则没有这样的承诺。
```
void bar() noexcept(true); // 等价于 noexcept
void baz() noexcept(false); // 默认行为，表示可能会抛出异常
```

重要性

优化机会：当编译器知道某个函数不会抛出异常时，它可以对这个函数调用进行一些优化。例如，在移动语义中，如果移动构造函数和移动赋值操作符声明为 noexcept，标准容器（如 std::vector）就能安全地使用它们来提高效率。
接口清晰度：明确告知使用者该函数是否会抛出异常，增强了代码的可读性和可维护性。
标准库利用：C++ 标准库中的许多组件会根据函数是否标记为 noexcept 来选择不同的内部实现策略，以优化性能或确保异常安全性。

注意事项

如果一个标有 noexcept 的函数实际运行时抛出了异常，程序将调用 std::terminate() 函数，这通常会导致程序立即终止，因此确保正确使用 noexcept 很重要。
不是所有的函数都适合标记为 noexcept，特别是那些可能需要通过抛出异常来进行错误处理的函数。在这种情况下，错误应该通过其他机制（如返回错误码）来报告。

合理使用 noexcept 关键字可以帮助编写更高效、更清晰的 C++ 代码。不过，在将其应用于函数之前，应当仔细考虑函数的实际行为和异常抛出情况。

在C++中的应用

noexcept 关键字在C++中的应用主要体现在以下几个方面：

1. 函数声明

可以使用 noexcept 来声明一个函数不会抛出异常。这不仅对编译器有提示作用，帮助其进行优化，而且对其他开发者来说也是一种明确的接口约定。

void safeFunction() noexcept;

如果你想根据某个条件来决定是否指定一个函数为 noexcept，可以使用布尔表达式：

void conditionallySafeFunction() noexcept(true); // 表示该函数不会抛出异常
void potentiallyUnsafeFunction() noexcept(false); // 默认行为，表示可能会抛出异常

2. 移动操作

对于自定义类型，如果你希望它们能够被标准库容器（如 std::vector）高效地移动，那么为其移动构造函数和移动赋值操作符添加 noexcept 是非常重要的。这是因为标准库在某些情况下会检查这些操作是否标记为 noexcept，以决定是使用拷贝还是移动。

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

3. 模板与 SFINAE

noexcept 可以作为模板参数的一部分，或用于SFINAE (Substitution Failure Is Not An Error) 技术中，以便选择最适合特定上下文的重载函数或模板实例化。例如，你可以编写一个函数模板，它只接受那些不抛出异常的操作：

template<typename T>
auto process(T&& arg) -> std::enable_if_t<noexcept(arg.someMethod()), void> {
    // 如果 someMethod 被标记为 noexcept，则此模板特化将被选中。
}

4. 异常安全性与性能优化

当一个函数被标记为 noexcept，并且实际运行时确实没有抛出异常，这可以让编译器做出更激进的优化，因为编译器知道无需为可能的异常处理生成额外的代码。此外，这也增强了程序的异常安全性，特别是在资源管理方面。

误用风险：如果错误地标记了一个实际上可能会抛出异常的函数为 noexcept，会导致调用 std::terminate() 并终止程序。因此，在标记函数为 noexcept 前，请确保了解该函数的所有可能执行路径及其异常抛出情况。
测试：对于复杂的函数，尤其是那些依赖于外部因素（如文件系统、网络等）的函数，确定其是否真的可以标记为 noexcept 可能需要经过充分的测试和分析。

通过合理利用 noexcept，不仅可以提高代码的性能，还能增强代码的清晰度和正确性。

应用案例

noexcept 关键字在C++中的应用案例广泛，尤其是在需要优化性能和确保异常安全性的场景中。以下是一些具体的使用案例：

1. 移动操作

在自定义类型中，如果你希望它们能够被标准库容器（如 std::vector）高效地移动，那么为其移动构造函数和移动赋值操作符添加 noexcept 是非常重要的。这是因为标准库在某些情况下会检查这些操作是否标记为 noexcept，以决定是使用拷贝还是移动。

class LargeData {
public:
    // 移动构造函数声明为 noexcept
    LargeData(LargeData&&) noexcept;
    
    // 移动赋值操作符也声明为 noexcept
    LargeData& operator=(LargeData&&) noexcept;
};

2. 标准库容器的插入与删除

当你向一个 std::vector 或其他标准库容器中添加或移除元素时，如果该元素类型的移动构造函数或移动赋值操作符是 noexcept 的，则标准库可以采取更高效的策略来执行这些操作，因为它知道这不会抛出异常从而不需要额外的异常安全措施。

std::vector<LargeData> vec;
vec.emplace_back(LargeData()); // 如果 LargeData 的移动操作是 noexcept，效率更高。

3. 模板编程中的 SFINAE

noexcept 可用于模板编程中，通过SFINAE (Substitution Failure Is Not An Error) 技术选择最适合特定上下文的重载函数或模板实例化。例如，你可以编写一个仅当某个表达式是 noexcept 时才有效的模板。

template<typename T>
auto safeOperation(T&& arg) -> std::enable_if_t<noexcept(arg.safeMethod()), void> {
    // 仅当 safeMethod() 被标记为 noexcept 时，此模板特化将被选中。
    arg.safeMethod();
}

4. 异常安全性

在资源管理类中，比如智能指针或文件句柄管理器，使用 noexcept 可以帮助确保在发生异常时不会泄露资源。因为析构函数不应该抛出异常，所以通常也会将析构函数标记为 noexcept。

class ResourceHandler {
public:
    ~ResourceHandler() noexcept { /* 确保资源释放过程不会抛出异常 */ }
};

5.综合应用案例

为了展示 noexcept 关键字的综合应用，让我们考虑一个具体的场景：实现一个简单的动态数组类（类似于 std::vector），该类需要支持高效的元素添加和移除操作，并且在可能的情况下使用移动语义以提高性能。在这个过程中，我们将利用 noexcept 来优化我们的容器并确保其异常安全性。

示例：自定义动态数组类

#include <iostream>
#include <algorithm> // std::move, std::copy

class DynamicArray {
private:
    int* array;
    size_t capacity;
    size_t size;

    void resize() {
        // 增加容量
        size_t newCapacity = (capacity == 0) ? 1 : capacity * 2;
        int* newArray = new int[newCapacity];
        
        // 使用移动或复制来填充新数组
        if constexpr (std::is_nothrow_move_constructible_v<int>) {
            std::move(array, array + size, newArray); // 如果int支持不抛出异常的移动构造函数，则使用移动
        } else {
            std::copy(array, array + size, newArray); // 否则使用复制
        }
        
        delete[] array;
        array = newArray;
        capacity = newCapacity;
    }

public:
    DynamicArray() : array(nullptr), capacity(0), size(0) {}
    
    ~DynamicArray() noexcept {
        delete[] array; // 析构函数声明为noexcept保证不会抛出异常
    }
    
    DynamicArray(DynamicArray&& other) noexcept : array(other.array), capacity(other.capacity), size(other.size) {
        other.array = nullptr;
        other.capacity = 0;
        other.size = 0;
    }
    
    DynamicArray& operator=(DynamicArray&& other) noexcept {
        if (this != &other) {
            delete[] array; // 清理已有资源
            
            array = other.array;
            capacity = other.capacity;
            size = other.size;
            
            other.array = nullptr;
            other.capacity = 0;
            other.size = 0;
        }
        return *this;
    }
    
    void push_back(int value) {
        if (size == capacity) {
            resize();
        }
        array[size++] = value;
    }
    
    size_t getSize() const { return size; }
    
    int getElement(size_t index) const { return array[index]; }
};

int main() {
    DynamicArray da;
    for (int i = 0; i < 10; ++i) {
        da.push_back(i);
    }
    
    for (size_t i = 0; i < da.getSize(); ++i) {
        std::cout << da.getElement(i) << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

解释与分析

resize 方法：在扩容时，我们首先检查类型 int 是否支持不抛出异常的移动构造函数（通过 std::is_nothrow_move_constructible_v<int>）。如果支持，则使用 std::move 来移动现有元素到新的更大的数组中；否则，使用 std::copy 进行复制。这样可以最大化地利用移动语义带来的性能优势。
移动构造函数与移动赋值操作符：这两个成员函数都被标记为 noexcept，这不仅向编译器表明它们不会抛出异常，从而允许标准库容器在必要时选择这些操作来提高效率，而且也增强了代码的异常安全性。
析构函数：同样被标记为 noexcept，确保在销毁对象时不会因为释放资源而抛出异常，这是非常重要的，因为析构函数不应该让程序崩溃或进入未定义状态。