C++异常安全代码编写原则

C++异常安全的核心保证等级有无抛出保证、基本保证和强保证。无抛出保证确保操作绝不抛出异常，是析构函数等关键操作的理想标准；基本保证要求异常发生时资源不泄露且状态有效，是多数函数应达到的最低要求；强保证则进一步要求操作要么完全成功，要么状态完全回滚，通常通过“复制-修改-交换”等事务性技术实现。这些等级为代码健壮性提供了明确衡量标准，指导开发者在不同场景下合理设计异常处理策略，确保程序在异常情况下仍能稳定运行，避免资源泄露或状态混乱。

在C++中，编写异常安全的代码，核心在于确保程序在遇到异常时，依然能保持资源不泄露、数据状态有效，并且能够优雅地恢复或终止。这并非仅仅是简单地用

try-catch

解决方案

要实现C++的异常安全，我们主要围绕几个关键原则和技术：资源获取即初始化（RAII）、明确的异常安全保证等级、以及恰当的事务性操作设计。在我看来，RAII是基石，它让资源管理变得几乎自动化，大大降低了手动处理异常时资源泄露的风险。但仅仅有RAII还不够，我们还需要在复杂的业务逻辑中，通过事务性设计，确保操作要么完全成功，要么完全不影响原有状态。这要求我们对每一次可能抛出异常的操作都心存敬畏，预设好“Plan B”。

C++异常安全的核心保证等级有哪些，为何它们如此重要？

谈到异常安全，我们通常会提到三个等级：无抛出保证（No-Throw Guarantee）、基本保证（Basic Guarantee）和强保证（Strong Guarantee）。理解它们，就像是给你的代码设定了不同的“抗压等级”。

• 无抛出保证（No-Throw Guarantee）：这是最理想的状态，意味着函数或操作绝不会抛出任何异常。通常，这适用于析构函数、交换操作（

  swap

  ）以及一些非常简单的、内部不涉及资源分配或可能失败的逻辑。我个人觉得，析构函数是这里最关键的，因为如果在析构函数中抛出异常，那程序几乎肯定会崩溃，或者导致更严重的资源泄露。想象一下，当一个异常正在传播时，另一个析构函数又抛出异常，那简直是一场灾难。所以，对于析构函数，我们总是力求做到“不抛出”，或者至少要将内部可能抛出的异常捕获并处理掉。

  立即学习“C++免费学习笔记（深入）”；

• 基本保证（Basic Guarantee）：如果操作失败并抛出异常，程序状态仍然是有效的，所有资源都不会泄露。但是，程序的状态可能已经改变，不再是操作开始之前的状态，也可能不是一个我们期望的“成功”状态。对我来说，这是大多数函数应该努力达到的最低标准。它意味着你不会因为一个异常而让整个系统陷入僵局，至少还能继续运行，即使结果可能不尽如人意。比如，一个向容器中插入元素的函数，如果失败了，容器可能处于一个未知但有效的状态（比如，元素没插入成功，但容器本身没有损坏），并且之前分配的内存都被正确释放了。

• 强保证（Strong Guarantee）：这是最严格的保证。如果操作成功，它会按照预期执行；如果操作失败并抛出异常，程序的状态会回滚到操作开始之前的状态，就像这个操作从未发生过一样。这通常通过“复制-修改-交换”（Copy-and-Swap）等事务性技术来实现。实现强保证往往需要更多的代码和性能开销，但它带来的好处是显而易见的：你可以在异常发生时完全忽略这次操作的影响，继续执行其他逻辑。我经常发现，在处理关键业务逻辑，比如数据库事务、复杂的数据结构修改时，强保证能够极大地简化错误处理的复杂性。

这些保证等级之所以重要，是因为它们为我们提供了一个衡量代码健壮性的标准，也指导我们如何设计和实现功能。盲目追求强保证是不现实的，但忽略基本保证则是危险的。

RAII（资源获取即初始化）如何成为C++异常安全的基石？

RAII，全称“Resource Acquisition Is Initialization”，直译过来是“资源获取即初始化”，在我看来，它更像是一种“资源管理即生命周期”的哲学。它的核心思想是：将资源的生命周期与对象的生命周期绑定。当对象创建时（通常在构造函数中），它获取资源；当对象销毁时（在析构函数中），它释放资源。

这听起来简单，但它的威力在于，C++语言保证了局部对象的析构函数在对象生命周期结束时（无论是正常退出作用域，还是因为异常传播而退出作用域）都会被调用。这意味着，无论你的函数执行到一半抛出异常，还是正常返回，那些通过RAII管理起来的资源，都会被安全地释放掉。

举个例子，我们经常手动管理文件句柄或互斥锁。没有RAII时，代码可能长这样：

问小白

免费使用DeepSeek满血版

下载

void process_data(const std::string& filename) {
    FILE* file = fopen(filename.c_str(), "r");
    if (!file) {
        throw std::runtime_error("Failed to open file");
    }
    // ... 处理文件数据 ...
    // 如果这里抛出异常，file就不会被关闭
    fclose(file); // 很容易忘记，或者在异常路径上被跳过
}

而使用RAII，比如

std::unique_ptr

class FileHandle {
public:
    FileHandle(const std::string& filename, const char* mode) {
        file_ = fopen(filename.c_str(), mode);
        if (!file_) {
            throw std::runtime_error("Failed to open file");
        }
    }
    ~FileHandle() {
        if (file_) {
            fclose(file_); // 析构函数保证被调用
        }
    }
    // 禁止拷贝，确保唯一所有权
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
    // 移动构造和赋值
    FileHandle(FileHandle&& other) noexcept : file_(other.file_) {
        other.file_ = nullptr;
    }
    FileHandle& operator=(FileHandle&& other) noexcept {
        if (this != &other) {
            if (file_) fclose(file_);
            file_ = other.file_;
            other.file_ = nullptr;
        }
        return *this;
    }

    FILE* get() const { return file_; }

private:
    FILE* file_;
};

void process_data_raii(const std::string& filename) {
    FileHandle file(filename, "r"); // 资源获取
    // ... 处理文件数据 ...
    // 无论这里发生什么，file_的析构函数都会被调用，文件会被安全关闭
} // file对象生命周期结束，析构函数被调用

std::unique_ptr

std::lock_guard

除了RAII，还有哪些高级技术可以确保复杂操作的强异常安全？

虽然RAII是基础，但在涉及多个步骤、多个资源或复杂数据结构修改的场景下，仅靠RAII可能难以提供强保证。这时，我们需要更高级的“事务性”技术，其中“复制-修改-交换”（Copy-and-Swap idiom）是我个人非常推崇的一种。

复制-修改-交换（Copy-and-Swap Idiom）

这个模式的核心思想是：

1. 复制（Copy）：对需要修改的对象或数据进行一份完整的复制。
2. 修改（Modify）：在复制品上进行所有必要的操作和修改。在这个阶段，如果发生异常，原始对象仍然保持不变，因为我们修改的是一个副本。
3. 交换（Swap）：如果所有修改都成功完成，没有抛出异常，那么将原始对象与修改后的副本进行一次原子性的交换。通常，这个交换操作本身应该是无抛出（no-throw）的。

让我们以一个自定义的动态数组类

MyVector

push_back

#include  // For std::swap
#include 
#include  // For internal use, or imagine a raw array

class MyVector {
public:
    MyVector() : data_(nullptr), size_(0), capacity_(0) {}
    ~MyVector() { delete[] data_; }

    MyVector(const MyVector& other)
        : data_(new int[other.capacity_]), size_(other.size_), capacity_(other.capacity_) {
        std::copy(other.data_, other.data_ + other.size_, data_);
    }

    MyVector(MyVector&& other) noexcept
        : data_(other.data_), size_(other.size_), capacity_(other.capacity_) {
        other.data_ = nullptr;
        other.size_ = 0;
        other.capacity_ = 0;
    }

    MyVector& operator=(MyVector other) noexcept { // 注意：这里参数是传值，利用了拷贝构造
        swap(*this, other);
        return *this;
    }

    friend void swap(MyVector& first, MyVector& second) noexcept {
        using std::swap;
        swap(first.data_, second.data_);
        swap(first.size_, second.size_);
        swap(first.capacity_, second.capacity_);
    }

    void push_back(int value) {
        if (size_ == capacity_) {
            // 1. 复制：创建一个新的、更大的MyVector副本
            //    这里我们直接创建一个新的内部数组
            size_t new_capacity = capacity_ == 0 ? 1 : capacity_ * 2;
            std::unique_ptr new_data(new int[new_capacity]); // RAII管理新内存

            // 2. 修改：将旧数据复制到新数组，并添加新元素
            std::copy(data_, data_ + size_, new_data.get());
            new_data[size_] = value;

            // 如果 new int[new_capacity] 抛出异常，或者 std::copy 抛出异常
            // 原始 MyVector 对象不会受到任何影响，因为它还在使用旧的 data_

            // 3. 交换：所有操作成功后，原子性地交换数据
            //    这里我们利用了move语义和swap函数
            delete[] data_; // 释放旧内存
            data_ = new_data.release(); // 接管新内存
            capacity_ = new_capacity;
            size_++;
        } else {
            data_[size_] = value;
            size_++;
        }
    }

    size_t size() const { return size_; }
    size_t capacity() const { return capacity_; }
    int operator[](size_t index) const {
        if (index >= size_) throw std::out_of_range("Index out of bounds");
        return data_[index];
    }

private:
    int* data_;
    size_t size_;
    size_t capacity_;
};

在这个

push_back

unique_ptr

new int[new_capacity]

std::bad_alloc

std::copy

new_data

unique_ptr

MyVector

data_

size_

capacity_

MyVector

push_back

除了Copy-and-Swap，还有一些其他策略：

• 事务性对象（Transactional Objects）：这是一种更通用的概念，可以应用于更复杂的场景。你可以设计一个“事务”对象，它记录所有将要执行的修改。只有当所有修改都被验证为成功后，才将这些修改“提交”到主对象。如果在此过程中发生异常，事务对象被销毁，所有未提交的修改都会被自动回滚。
• 两阶段提交（Two-Phase Commit）：在分布式系统或涉及多个独立资源（如数据库和文件系统）的场景中，两阶段提交可以确保所有操作要么全部成功，要么全部失败。虽然这通常是系统级设计，但其思想也可以在单个应用程序的复杂操作中借鉴。

在我看来，选择哪种技术，取决于你代码的复杂性、性能要求以及你愿意为此付出的设计和实现成本。但无论如何，始终保持对异常的警惕，并有意识地设计异常安全的代码，是每一个C++开发者都应该铭记的原则。