C++异常处理：stdexcept使用与最佳实践

1. 为什么我们需要异常处理？

在C++开发中，错误处理一直是个令人头疼的问题。记得我刚入行时，经常看到代码里充斥着各种错误码检查，函数返回值被用来传递错误状态，这不仅让代码变得臃肿，还容易遗漏错误检查。直到我开始使用stdexcept，才真正体会到异常处理的优雅之处。

stdexcept是C++标准库中专门用于异常处理的头文件，它定义了一系列标准异常类，为我们提供了一种结构化的错误处理机制。与传统的错误码相比，异常处理有几个显著优势：

1. 错误处理与正常逻辑分离，代码更清晰
2. 异常会自动传播，不需要每层函数都检查错误
3. 异常对象可以携带丰富的错误信息
4. 不同类型的错误可以用不同的异常类表示

2. stdexcept中的核心异常类解析

2.1 基础异常类层次结构

stdexcept中的异常类主要分为两大类，形成了一个清晰的继承体系：

code复制std::exception
├── std::logic_error
│   ├── std::domain_error
│   ├── std::invalid_argument
│   ├── std::length_error
│   └── std::out_of_range
└── std::runtime_error
    ├── std::range_error
    ├── std::overflow_error
    ├── std::underflow_error
    └── std::system_error

这个分类很有讲究：logic_error表示程序逻辑错误，应该在编码阶段避免；runtime_error表示运行时可能发生的错误，通常难以完全避免。

2.2 常用异常类使用场景

invalid_argument：当函数接收到不符合预期的参数时抛出。比如计算平方根时传入负数：

cpp复制double sqrt(double x) {
    if (x < 0) 
        throw std::invalid_argument("负数不能求平方根");
    // 计算逻辑...
}

out_of_range：访问超出范围的元素时使用。比如vector的下标检查：

cpp复制int getElement(const std::vector<int>& vec, size_t index) {
    if (index >= vec.size())
        throw std::out_of_range("索引超出范围");
    return vec[index];
}

runtime_error：当发生无法在编码阶段预测的错误时使用。比如文件读取失败：

cpp复制std::string readFile(const std::string& filename) {
    std::ifstream file(filename);
    if (!file.is_open())
        throw std::runtime_error("无法打开文件: " + filename);
    // 读取逻辑...
}

3. 异常处理的最佳实践

3.1 抛出异常的技巧

抛出异常时，有几点需要注意：

1. 尽量使用标准异常类，保持代码一致性
2. 错误信息要具体，包含相关变量值
3. 不要在析构函数中抛出异常
4. 异常对象通常按值抛出，按引用捕获

一个良好的异常抛出示例：

cpp复制class DatabaseConnection {
public:
    void connect(const std::string& url) {
        if (url.empty())
            throw std::invalid_argument("数据库URL不能为空");
        
        if (!tryConnect(url))
            throw std::runtime_error("连接数据库失败，URL: " + url);
        
        // 连接成功逻辑...
    }
};

3.2 捕获和处理异常

捕获异常时，应该从特定到一般：

cpp复制try {
    // 可能抛出异常的代码
} catch (const std::invalid_argument& e) {
    // 处理参数错误
    std::cerr << "参数错误: " << e.what() << std::endl;
} catch (const std::runtime_error& e) {
    // 处理运行时错误
    std::cerr << "运行时错误: " << e.what() << std::endl;
} catch (const std::exception& e) {
    // 捕获所有标准异常
    std::cerr << "标准异常: " << e.what() << std::endl;
} catch (...) {
    // 捕获所有其他异常
    std::cerr << "未知异常发生" << std::endl;
}

重要提示：不要滥用catch(...)，这会让调试变得困难。只在确实需要捕获所有异常时使用，并且通常应该重新抛出或记录日志。

4. 自定义异常类的实现

虽然标准异常类已经覆盖了大部分场景，但有时我们需要自定义异常类来表达特定的错误。一个好的自定义异常类应该：

1. 继承自std::exception或其子类
2. 实现what()方法返回错误信息
3. 提供足够的上下文信息

示例：

cpp复制class NetworkException : public std::runtime_error {
    int error_code_;
    std::string details_;
    
public:
    NetworkException(int code, const std::string& msg, const std::string& details)
        : std::runtime_error(msg), error_code_(code), details_(details) {}
    
    int error_code() const { return error_code_; }
    const std::string& details() const { return details_; }
    
    const char* what() const noexcept override {
        static std::string full_msg;
        full_msg = std::string(std::runtime_error::what()) + 
                  " [code:" + std::to_string(error_code_) + 
                  ", details:" + details_ + "]";
        return full_msg.c_str();
    }
};

使用这个自定义异常：

cpp复制void sendRequest() {
    if (networkError)
        throw NetworkException(404, "资源未找到", "请求的URL不存在");
    // 正常逻辑...
}

5. 异常安全编程技巧

5.1 RAII原则

资源获取即初始化(RAII)是C++中保证异常安全的核心技术。基本思想是使用对象生命周期管理资源：

cpp复制class FileHandle {
    FILE* file_;
public:
    explicit FileHandle(const char* filename) : file_(fopen(filename, "r")) {
        if (!file_) throw std::runtime_error("无法打开文件");
    }
    
    ~FileHandle() { if (file_) fclose(file_); }
    
    // 禁用拷贝
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
    
    // 允许移动
    FileHandle(FileHandle&& other) : file_(other.file_) { other.file_ = nullptr; }
    FileHandle& operator=(FileHandle&& other) {
        if (this != &other) {
            if (file_) fclose(file_);
            file_ = other.file_;
            other.file_ = nullptr;
        }
        return *this;
    }
    
    // 使用接口
    void read(void* buf, size_t size) {
        if (fread(buf, 1, size, file_) != size)
            throw std::runtime_error("读取文件失败");
    }
};

5.2 noexcept关键字

noexcept表示函数保证不会抛出异常，这可以让编译器进行更多优化：

cpp复制void simpleOperation() noexcept {
    // 这个函数保证不会抛出异常
}

但要注意，如果noexcept函数确实抛出了异常，程序会直接终止。所以只在确实不会抛出异常的函数上使用noexcept。

6. 性能考量与异常开销

异常处理确实会带来一些性能开销，主要体现在：

1. 抛出异常时栈展开(stack unwinding)的成本
2. 异常处理机制的运行时支持
3. 可能影响编译器优化

但在现代C++实现中，异常处理的性能已经相当不错。更重要的是，异常应该用于真正的异常情况，而不是常规控制流。一些性能敏感的场景可以考虑：

• 使用错误码处理预期内的错误
• 将可能抛出异常的代码移出关键路径
• 预检查条件避免异常抛出

7. 常见陷阱与调试技巧

7.1 异常处理中的常见错误

1. 异常屏蔽：在catch块中捕获异常但不处理，导致问题被隐藏
2. 资源泄漏：抛出异常前忘记释放资源
3. 异常类型不匹配：捕获的异常类型与实际抛出的不匹配
4. 异常安全漏洞：异常导致对象状态不一致

7.2 调试异常的技巧

1. 使用调试器设置异常断点
2. 在catch块中打印调用栈
3. 确保异常信息包含足够上下文
4. 使用静态分析工具检查异常安全问题

一个有用的调试技巧是在main函数中设置全局异常处理器：

cpp复制int main() {
    try {
        // 应用程序代码
    } catch (const std::exception& e) {
        std::cerr << "未捕获的异常: " << e.what() << std::endl;
        printStackTrace();  // 自定义函数打印调用栈
        return 1;
    }
    return 0;
}

8. 现代C++中的异常处理演进

C++11以来，异常处理有一些重要改进：

1. noexcept说明符：更清晰地表达函数异常规范
2. 异常指针：std::exception_ptr允许跨线程传递异常
3. 嵌套异常：std::nested_exception可以保存异常链
4. 系统错误：std::system_error整合了系统错误码

例如，使用exception_ptr处理异步异常：

cpp复制std::exception_ptr eptr;

void worker() {
    try {
        // 可能抛出异常的工作
    } catch (...) {
        eptr = std::current_exception();
    }
}

int main() {
    std::thread t(worker);
    t.join();
    
    if (eptr) {
        try {
            std::rethrow_exception(eptr);
        } catch (const std::exception& e) {
            std::cerr << "工作线程异常: " << e.what() << std::endl;
        }
    }
}

在实际项目中，我逐渐形成了自己的异常处理哲学：对于预期可能发生的、可恢复的错误（如用户输入错误），使用错误码；对于真正的异常情况（如内存耗尽、系统错误），使用异常。这种区分让代码既保持了清晰性，又不会过度依赖异常处理。