C++ 异常安全保证：实现基本、强、无抛出保证的代码

好的，咱们今天来聊聊 C++ 里的“异常安全”这个磨人的小妖精！ 别怕，虽然听起来像个高深莫测的概念，但其实掌握了它，你的代码就能更稳健、更靠谱，就像穿了防弹衣一样，遇到意外情况也能尽量保证不出大乱子。

开场白：异常，程序界的“意外惊喜”

想象一下，你正在兴高采烈地做饭，突然煤气灶罢工了！ 这就是程序世界里的“异常”。 异常是指程序在运行过程中遇到的非正常情况，比如除数为零、内存不足、文件不存在等等。 如果你不处理这些“意外惊喜”，程序很可能就直接崩溃给你看，这可太尴尬了！

C++ 提供了 try...catch 机制来捕获和处理异常，就像给程序装了个安全网。 但是，仅仅捕获异常还不够，更重要的是要保证在异常发生时，程序的状态仍然是可控的，不会留下一些烂摊子。 这就是“异常安全”要解决的问题。

异常安全保证的三种境界

C++ 的异常安全保证分为三个等级，就像武侠小说里的三种境界：

1. 基本保证 (Basic Guarantee):

   • 这是最基本的要求。
   • 保证即使在异常抛出后，程序的状态仍然是有效的。 也就是说，程序不会崩溃，不会出现内存泄漏，对象不会被破坏，但具体的状态可能和操作开始前不一样。
   • 你可以理解为，至少你的程序不会变得更糟，虽然可能没达到你的预期目标。

2. 强保证 (Strong Guarantee):

   • 这是更高的要求。
   • 保证操作要么完全成功，要么完全不产生任何影响。 如果操作过程中抛出异常，程序的状态会恢复到操作开始之前的状态，就像什么都没发生过一样。
   • 可以理解为“要么全有，要么全无”，就像事务的原子性一样。

3. 无抛出保证 (No-Throw Guarantee):

   • 这是最高的要求。
   • 保证操作绝对不会抛出异常。
   • 这种保证通常只适用于一些非常基础的操作，比如内置类型的赋值、析构函数等。

用表格总结一下：

保证级别	描述	难度	适用场景
基本保证	即使异常抛出，程序的状态仍然有效，不会崩溃、内存泄漏或对象被破坏。	简单	大部分情况，这是最起码的要求。
强保证	操作要么完全成功，要么完全不产生任何影响，程序的状态恢复到操作开始之前的状态。	中等偏上	对于需要保证数据一致性的操作，例如数据库事务、银行转账等。
无抛出保证	操作绝对不会抛出异常。	难，有时不可能	非常基础的操作，例如内置类型的赋值、析构函数、内存分配等。 也用于异常处理代码本身，因为异常处理代码如果抛出异常，可能会导致程序崩溃。

代码实战：三种保证的实现

接下来，咱们通过一些代码示例，来看看如何实现这三种异常安全保证。

1. 基本保证：让程序“活下来”

假设我们有一个 Vector 类，用来存储一组整数：

#include <iostream>
#include <vector>
#include <stdexcept>

class Vector {
private:
    int* data;
    size_t size;
    size_t capacity;

public:
    // 构造函数
    Vector(size_t initialCapacity) : size(0), capacity(initialCapacity) {
        data = new int[capacity];
    }

    // 拷贝构造函数
    Vector(const Vector& other) : size(other.size), capacity(other.capacity) {
        data = new int[capacity];
        for (size_t i = 0; i < size; ++i) {
            data[i] = other.data[i];
        }
    }

    // 赋值运算符
    Vector& operator=(const Vector& other) {
        if (this != &other) {
            // 1. 分配新的内存
            int* newData = new int[other.capacity];

            // 2. 拷贝数据
            for (size_t i = 0; i < other.size; ++i) {
                newData[i] = other.data[i];
            }

            // 3. 释放旧的内存
            delete[] data;

            // 4. 更新成员变量
            data = newData;
            size = other.size;
            capacity = other.capacity;
        }
        return *this;
    }

    // 添加元素
    void push_back(int value) {
        if (size == capacity) {
            // 扩容
            size_t newCapacity = capacity == 0 ? 1 : capacity * 2;
            int* newData = new int[newCapacity];
            for (size_t i = 0; i < size; ++i) {
                newData[i] = data[i];
            }
            delete[] data;
            data = newData;
            capacity = newCapacity;
        }
        data[size++] = value;
    }

    // 访问元素
    int& at(size_t index) {
        if (index >= size) {
            throw std::out_of_range("Index out of range");
        }
        return data[index];
    }

    // 析构函数
    ~Vector() {
        delete[] data;
    }

    size_t getSize() const {
        return size;
    }

    size_t getCapacity() const {
        return capacity;
    }
};

int main() {
    try {
        Vector v(2);
        v.push_back(10);
        v.push_back(20);
        v.push_back(30); // 触发扩容

        std::cout << "Vector size: " << v.getSize() << std::endl;
        std::cout << "Vector capacity: " << v.getCapacity() << std::endl;

        std::cout << "Element at index 1: " << v.at(1) << std::endl;
        v.at(5); // 触发异常
    } catch (const std::exception& e) {
        std::cerr << "Exception caught: " << e.what() << std::endl;
    }

    return 0;
}

在这个例子中，如果 push_back 在扩容过程中抛出异常（比如 new 失败），data 指针会被释放，但 size 和 capacity 仍然保持原来的值。 虽然 Vector 对象的状态可能不完全一致，但至少不会崩溃，不会出现内存泄漏。 这就是基本保证。 析构函数保证不抛出异常，这也是异常安全的基本要求。

2. 强保证：要么成功，要么回到原点

要实现强保证，通常需要使用“拷贝并交换 (Copy-and-Swap)” 技术。 咱们改造一下上面的赋值运算符：

#include <iostream>
#include <vector>
#include <stdexcept>
#include <algorithm> // 需要包含 algorithm 头文件

class Vector {
private:
    int* data;
    size_t size;
    size_t capacity;

public:
    // 构造函数
    Vector(size_t initialCapacity) : size(0), capacity(initialCapacity) {
        data = new int[capacity];
    }

    // 拷贝构造函数
    Vector(const Vector& other) : size(other.size), capacity(other.capacity) {
        data = new int[capacity];
        for (size_t i = 0; i < size; ++i) {
            data[i] = other.data[i];
        }
    }

    // 赋值运算符 (使用 Copy-and-Swap)
    Vector& operator=(const Vector& other) {
        if (this != &other) {
            // 1. 创建一个副本
            Vector temp(other);  // 利用拷贝构造函数

            // 2. 交换数据
            std::swap(data, temp.data);
            std::swap(size, temp.size);
            std::swap(capacity, temp.capacity);

            // 3. temp 在析构时会自动释放旧的数据
        }
        return *this;
    }

    // 添加元素
    void push_back(int value) {
        if (size == capacity) {
            // 扩容
            size_t newCapacity = capacity == 0 ? 1 : capacity * 2;
            // 使用 try-catch 保证强异常安全
            try {
                int* newData = new int[newCapacity];
                for (size_t i = 0; i < size; ++i) {
                    newData[i] = data[i];
                }
                delete[] data;
                data = newData;
                capacity = newCapacity;
            } catch (...) {
                // 如果 new 失败，不改变对象状态，直接抛出异常
                throw;
            }
        }
        data[size++] = value;
    }

    // 访问元素
    int& at(size_t index) {
        if (index >= size) {
            throw std::out_of_range("Index out of range");
        }
        return data[index];
    }

    // 析构函数
    ~Vector() {
        delete[] data;
    }

    size_t getSize() const {
        return size;
    }

    size_t getCapacity() const {
        return capacity;
    }
};

int main() {
    try {
        Vector v1(2);
        v1.push_back(10);
        v1.push_back(20);

        Vector v2(1);
        v2 = v1; // 使用赋值运算符

        std::cout << "v2 size: " << v2.getSize() << std::endl;
        std::cout << "v2 capacity: " << v2.getCapacity() << std::endl;

         Vector v3(2);
        v3.push_back(1);
        v3.push_back(2);
        try {
            // 模拟内存分配失败，使 push_back 抛出异常
            // 注意：这只是模拟，实际中无法直接控制 new 的行为
            Vector v4(1);
            // 在 v4 分配内存之前，设置一个标志位，在 push_back 中检查
            // 这里无法直接模拟内存分配失败，所以略过这部分
            // 假设 push_back 在分配内存时抛出了异常
            v4.push_back(10); // 这一步可能会抛出异常
            v4.push_back(20);
            v4.push_back(30);
        } catch (const std::exception& e) {
            std::cerr << "Exception caught during push_back: " << e.what() << std::endl;
            // 捕获异常后，v3 应该保持不变
            std::cout << "v3 size after exception: " << v3.getSize() << std::endl;
        }

        std::cout << "v1 size: " << v1.getSize() << std::endl;
        std::cout << "v1 capacity: " << v1.getCapacity() << std::endl;

        std::cout << "Element at index 1: " << v1.at(1) << std::endl;
        v1.at(5); // 触发异常
    } catch (const std::exception& e) {
        std::cerr << "Exception caught: " << e.what() << std::endl;
    }

    return 0;
}

这个赋值运算符的流程是：

1. 拷贝： 先创建一个 other 对象的副本 temp。 如果拷贝构造函数抛出异常，原来的对象 *this 不会受到任何影响。
2. 交换： 然后，使用 std::swap 函数交换 *this 和 temp 的内部数据（指针、大小、容量）。 std::swap 通常是无抛出保证的。
3. 析构： 当 temp 对象销毁时，它会释放原来 *this 对象的数据。

这样，如果拷贝过程中抛出异常，原来的对象 *this 仍然保持不变，实现了强保证。

push_back 函数也需要进行修改，保证在扩容过程中，如果 new 失败，不会改变对象的状态。 我们使用 try-catch 块来捕获异常，如果 new 失败，直接抛出异常，不进行任何状态修改。

3. 无抛出保证：绝对不能出错！

无抛出保证通常使用 noexcept 关键字来声明。 例如，析构函数默认就是 noexcept 的。 有些操作，比如移动构造函数和移动赋值运算符，也可以声明为 noexcept，如果它们确实不会抛出异常。

#include <iostream>
#include <vector>
#include <stdexcept>
#include <algorithm> // 需要包含 algorithm 头文件

class Vector {
private:
    int* data;
    size_t size;
    size_t capacity;

public:
    // 构造函数
    Vector(size_t initialCapacity) : size(0), capacity(initialCapacity), data(new int[capacity]) {}

    // 拷贝构造函数
    Vector(const Vector& other) : size(other.size), capacity(other.capacity), data(new int[capacity]) {
        std::copy(other.data, other.data + size, data);
    }

    // 移动构造函数
    Vector(Vector&& other) noexcept : data(other.data), size(other.size), capacity(other.capacity) {
        other.data = nullptr;
        other.size = 0;
        other.capacity = 0;
    }

    // 赋值运算符 (使用 Copy-and-Swap)
    Vector& operator=(const Vector& other) {
        if (this != &other) {
            Vector temp(other);
            std::swap(data, temp.data);
            std::swap(size, temp.size);
            std::swap(capacity, temp.capacity);
        }
        return *this;
    }

    // 移动赋值运算符
    Vector& operator=(Vector&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            capacity = other.capacity;

            other.data = nullptr;
            other.size = 0;
            other.capacity = 0;
        }
        return *this;
    }

    // 添加元素
    void push_back(int value) {
        if (size == capacity) {
            size_t newCapacity = capacity == 0 ? 1 : capacity * 2;
            try {
                int* newData = new int[newCapacity];
                std::copy(data, data + size, newData);
                delete[] data;
                data = newData;
                capacity = newCapacity;
            } catch (...) {
                throw; // 抛出异常，维持强异常安全保证
            }
        }
        data[size++] = value;
    }

    // 访问元素
    int& at(size_t index) {
        if (index >= size) {
            throw std::out_of_range("Index out of range");
        }
        return data[index];
    }

    // 析构函数
    ~Vector() noexcept {
        delete[] data;
    }

    size_t getSize() const {
        return size;
    }

    size_t getCapacity() const {
        return capacity;
    }
};

在这个例子中，移动构造函数和移动赋值运算符都声明为 noexcept。 这意味着它们保证不会抛出异常。 这对于提高程序的性能和可靠性非常重要。 析构函数也必须是 noexcept 的，否则在异常处理过程中可能会导致程序崩溃。

一些建议和注意事项

• 尽量使用 RAII (Resource Acquisition Is Initialization): RAII 是一种资源管理技术，它利用对象的生命周期来管理资源。 例如，可以使用智能指针（std::unique_ptr、std::shared_ptr）来自动管理内存，避免内存泄漏。
• 使用标准库容器： 标准库容器（std::vector、std::string 等）已经实现了良好的异常安全保证，可以直接使用，避免重复造轮子。
• 小心第三方库： 如果使用第三方库，要了解它们的异常安全保证，避免引入潜在的风险。
• 测试，测试，再测试： 编写单元测试来验证你的代码是否满足异常安全保证。

总结：让你的代码更“抗造”

异常安全是一个重要的概念，它可以帮助你编写更健壮、更可靠的 C++ 代码。 虽然实现异常安全需要一定的技巧和经验，但只要掌握了基本原则，并坚持实践，你就能写出更“抗造”的代码，让你的程序在面对“意外惊喜”时也能优雅地应对。

希望这次讲座对你有所帮助！ 记住，写出好的代码就像做一道美味的菜，需要精心挑选食材（好的设计），掌握烹饪技巧（编码技巧），并不断尝试和改进（测试和优化）。 祝你编程愉快！