在上一篇中，我们讨论了如何在 C++ 语言中自定义异常，以便更好地处理错误情况。自定义异常可以使得程序的异常处理更加清晰和灵活。然而，仅仅依靠自定义异常并不能保证代码的“异常安全”。在本篇中，我们将重点讨论如何设计异常安全的代码，以减少或消除异常带来的不利影响。

什么是异常安全

在 C++ 中，异常安全意味着在遇到异常时，程序的状态不会处于不确定或部分完成的状态。简单来说，如果代码在异常发生后能够保持系统的一致性，那么它就是“异常安全”的。

异常安全级别

异常安全的设计通常有几个级别，从低到高如下：

基本保证：如果发生异常，所有的资源（如内存、文件句柄等）都是被释放的，程序不会崩溃。
强保证：如果发生异常，程序将保持不变，即没有任何状态改变。因此，如果发生异常，函数的调用者在函数调用前后看到的状态完全一致。
无异常安全：没有保证，可能会导致资源泄漏或状态不一致。

在设计一个函数时，我们应尽量追求更高的异常安全级别。

如何实现异常安全

实现异常安全需要遵循某些原则和技术。接下来，我们将详细讨论这些原则并提供示例代码。

1. 使用 RAII（资源获取即初始化）

RAII 是 C++ 中一个非常重要的编程理念，通过将资源的生命周期与对象的生命周期绑定，我们可以确保在异常发生时资源能够被自动释放。

#include <iostream>
#include <memory>

class Resource {
public:
    Resource() { std::cout << "Resource acquired\n"; }
    ~Resource() { std::cout << "Resource released\n"; }
};

void functionThatMightThrow() {
    std::unique_ptr<Resource> res(new Resource());
    // 正常执行条件...
    // 模拟抛出异常
    throw std::runtime_error("An error occurred");
}

int main() {
    try {
        functionThatMightThrow();
    } catch (const std::exception &e) {
        std::cout << "Caught an exception: " << e.what() << '\n';
    }
    // Resource will automatically be released even if an exception occurs
    return 0;
}

在上面的代码中，当 functionThatMightThrow 函数抛出异常时，Resource 对象会被正确释放，确保了程序资源的安全。

2. 采用“复制-并交换”技术

对于资源管理类（如自定义的容器类），使用“复制-并交换”技术可以提供强保证。其思路是提供一个拷贝构造函数和一个交换函数，在发生异常时，保证原对象保持不变。

#include <iostream>
#include <memory>
#include <stdexcept>

class MyString {
public:
    MyString(const char* str) : data(new char[strlen(str) + 1]) {
        if (!data) throw std::runtime_error("Memory allocation failed");
        strcpy(data, str);
    }

    // 拷贝构造函数
    MyString(const MyString& other) : data(new char[strlen(other.data) + 1]) {
        if (!data) throw std::runtime_error("Memory allocation failed");
        strcpy(data, other.data);
    }

    // 交换函数
    friend void swap(MyString& first, MyString& second) {
        using std::swap;
        swap(first.data, second.data);
    }

    // 赋值运算符
    MyString& operator=(MyString other) {
        swap(*this, other);
        return *this;
    }

    ~MyString() { delete[] data; }

private:
    char* data;
};

int main() {
    try {
        MyString str1("Hello");
        MyString str2("World");
        str2 = str1;  // 调用赋值运算符
    } catch (const std::exception &e) {
        std::cout << "Caught an exception: " << e.what() << '\n';
    }
    return 0;
}

这里面通过采用 swap 和拷贝构造函数，确保了赋值操作的异常安全性，即使在构造新对象时发生异常，原对象的状态依然不会改变。

3. 使用智能指针

在现代 C++ 编程中，使用智能指针（如 std::unique_ptr 和 std::shared_ptr）来管理动态资源，可以大幅简化资源管理和异常安全的问题。

#include <iostream>
#include <memory>

void processResource(std::unique_ptr<int> resource) {
    // 模拟处理资源
    // throw std::runtime_error("Error during processing");
}

int main() {
    try {
        std::unique_ptr<int> res(new int(42));
        processResource(std::move(res)); // 将资源传递
    } catch (const std::exception &e) {
        std::cout << "Caught an exception: " << e.what() << '\n';
    }
    // 这里不会出现内存泄漏
    return 0;
}

在这个示例中，通过 std::unique_ptr 来管理资源，可以确保在抛出异常时资源会被正确释放。

结论

通过合理的设计和使用现代 C++ 特性（如 RAII、复制-并交换、智能指针），我们可以创建出异常安全的代码。在下一篇中，我们将转向多线程编程，讨论线程的基本概念。这将使我们更好地理解如何在并发环境中处理异常安全的设计。

希望本篇的内容能够帮助您更好地理解如何在 C++ 中实现异常安全的代码设计。

Jupyter AI

15 异常处理机制之异常安全的代码设计