异常安全与RAII：异常处理的开销、RAII资源管理、noexcept规范

异常安全这个话题，说实话，在C++社区里争议一直不小。有人觉得异常是魔鬼，有人觉得不用异常C++就白学了。我个人态度比较务实——异常本身不是问题，问题是你怎么用它。

今天我们就来聊聊异常处理的真实开销、RAII这个老朋友怎么帮我们管好资源，以及noexcept这个容易被忽略的关键字。

异常处理的开销：到底贵不贵？

很多人一听到异常就说「性能差」。嗯，这话对了一半。

异常的开销分两种情况：

• 正常路径（没有异常抛出）：现代编译器基本能做到零开销。你写个try-catch，只要不抛异常，生成的代码和没写差不多。
• 异常路径（真的抛了）：这个就贵了。栈展开、析构函数调用、匹配catch块……一套流程下来，比普通return慢几十倍甚至上百倍。

我在项目中遇到过一种情况：某个团队把异常当作普通错误码来用，频繁抛出捕获。结果性能监控一看，那个模块的延迟直接炸了。后来改成错误码+日志，问题就解决了。

来看一个简单的性能对比：

// 方式一：用异常
void process_with_exception() {
    try {
        // 可能抛异常的操作
        do_something();
    } catch (const std::exception& e) {
        // 处理
    }
}

// 方式二：用错误码
int process_with_error_code() {
    int ret = do_something();
    if (ret != 0) {
        return ret;
    }
    return 0;
}

你想想看，如果do_something()99.9%的情况下都成功，那两种写法性能几乎一样。但如果它经常失败，异常版本就会慢很多。

RAII资源管理：C++最优雅的设计

RAII，全称是Resource Acquisition Is Initialization。名字挺绕，说白了就是：资源在构造函数里拿，在析构函数里放。

为什么这玩意儿重要？因为异常一旦抛出，你手动写的资源释放代码可能根本跑不到。

用RAII改写一下：

// 不安全的写法
void unsafe_func() {
    int* data = new int[1024];
    // 如果这里抛异常，data就泄漏了
    process(data);
    delete[] data;
}

// RAII写法
void safe_func() {
    std::vector<int> data(1024);
    // 即使process抛异常，vector的析构函数也会自动释放内存
    process(data.data());
}

RAII的好处很明显：

• 自动释放：析构函数一定会被调用，不管你是正常返回还是异常退出
• 异常安全：栈展开时会自动调用所有局部对象的析构函数
• 代码简洁：不用到处写try-catch-finally

常见的RAII封装包括：

资源类型	RAII封装
动态内存	std::unique_ptr, std::shared_ptr, std::vector
文件句柄	std::fstream（析构时自动关闭）
互斥锁	std::lock_guard, std::unique_lock
数据库连接	自定义RAII包装类

noexcept规范：给编译器一个承诺

noexcept是C++11引入的关键字。它告诉编译器：这个函数不会抛异常。

为什么需要这个？两个原因：

1. 性能优化：编译器知道函数不会抛异常，就可以生成更高效的代码。不用保留栈展开信息，不用生成异常处理表。
2. 移动语义：std::vector在扩容时，如果移动构造函数是noexcept的，就会用移动而不是拷贝。否则，为了保证异常安全，只能用拷贝。

来看一个实际例子：

class MyData {
public:
    // 移动构造函数标记为noexcept
    MyData(MyData&& other) noexcept 
        : ptr_(other.ptr_) {
        other.ptr_ = nullptr;
    }
    
    // 拷贝构造函数
    MyData(const MyData& other) {
        ptr_ = new int(*other.ptr_);
    }
    
private:
    int* ptr_ = nullptr;
};

std::vector<MyData> vec;
vec.push_back(MyData{});  // 如果移动是noexcept，这里用移动；否则用拷贝

我记得有一次优化一个高频交易系统，就是把几个关键函数加上noexcept，性能提升了大概5%。虽然不多，但白捡的优化谁不要呢？

什么时候该用noexcept？

• 移动构造函数和移动赋值运算符（强烈建议）
• swap函数
• 析构函数（C++11默认就是noexcept）
• 那些你确定不会失败的操作，比如简单的getter

异常安全等级：你的代码有多安全？

异常安全通常分三个等级：

等级	含义	例子
基本保证	抛出异常后，资源不泄漏，对象处于有效但不确定的状态	大部分标准库容器操作
强保证	操作要么完全成功，要么回滚到操作前的状态	std::vector::push_back（使用拷贝时）
不抛保证	函数永远不会抛出异常	noexcept函数、析构函数

我个人建议：尽量做到强保证。如果做不到，至少保证基本保证。不抛保证只留给那些确实不会失败的操作。

实现强保证的一个常用技巧是「copy-and-swap」：

class Widget {
public:
    void set_data(const std::vector<int>& new_data) {
        // 先在临时对象上操作
        auto temp = new_data;
        // 如果上面抛异常，原对象不受影响
        // 最后用不抛异常的swap交换
        data_.swap(temp);
    }
    
private:
    std::vector<int> data_;
};

这个模式我用了很多年，简单可靠。你想想看，如果直接在data_上操作，万一中间抛异常，data_就处于半修改状态。用临时对象+swap，就安全多了。

知识体系总览

下面这张图总结了异常安全与RAII的核心脉络：

异常安全不是一蹴而就的。它需要你在设计阶段就想清楚：哪些操作可能失败？失败了怎么办？资源怎么管理？

我个人经验是：先把RAII用好，再考虑noexcept，最后才是异常安全等级。这个顺序走下来，大部分问题都能提前规避。

---

公众号:蓝海资料掘金营，微信deep3321