1. 为什么C++程序员必须掌握异常处理？

在C++开发中，我见过太多因为异常处理不当导致的灾难性后果。有一次线上服务崩溃，追查发现是一个简单的文件读取操作没有捕获异常，导致整个进程退出。这正是为什么异常处理不是可选技能，而是C++开发者的生存必备。

异常机制与传统的错误码返回机制有本质区别。错误码需要主动检查，而异常是主动"抛出"的。当函数遇到无法处理的异常情况时，它可以抛出一个异常对象，这个异常会沿着调用栈向上传播，直到找到匹配的catch块。这种机制将正常逻辑与错误处理分离，使代码更清晰。

关键认知：异常处理不是用来处理预期内的错误（如用户输入错误），而是处理程序运行时的意外情况（如内存不足、文件损坏等）。

2. C++异常处理的核心语法

2.1 基本try-catch块结构

标准的异常处理结构包含三个关键字：

try { // 可能抛出异常的代码 if (error_condition) { throw std::runtime_error("Something went wrong"); } } catch (const std::exception& e) { // 处理异常 std::cerr << "Error: " << e.what() << std::endl; } catch (...) { // 捕获所有未处理的异常 std::cerr << "Unknown exception caught" << std::endl; }

2.2 throw的多种用法

throw不仅可以抛出内置异常类型，还可以自定义异常类：

class NetworkException : public std::runtime_error { public: NetworkException(const std::string& msg) : std::runtime_error(msg) {} }; void connectToServer() { if (connection_failed) { throw NetworkException("Connection timeout"); } }

2.3 异常规格说明（C++11后已弃用）

旧版C++使用throw()声明可能抛出的异常类型，但在C++11后已被noexcept替代：

void safeFunction() noexcept { // 保证不抛出异常 // 函数实现 }

3. 标准库异常类体系

C++标准库提供了一套完整的异常类层次结构：

std::exception ├── std::logic_error │ ├── std::invalid_argument │ ├── std::domain_error │ └── std::length_error ├── std::runtime_error │ ├── std::overflow_error │ ├── std::underflow_error │ └── std::range_error └── std::bad_alloc

实际使用时，应根据场景选择合适的异常类型：

void processInput(int value) { if (value < 0) { throw std::invalid_argument("Value cannot be negative"); } if (value > MAX_LIMIT) { throw std::out_of_range("Value exceeds maximum limit"); } }

4. 异常安全编程实践

4.1 RAII原则的应用

资源获取即初始化(RAII)是确保异常安全的核心技术：

class FileHandler { public: FileHandler(const std::string& filename) : file_(fopen(filename.c_str(), "r")) { if (!file_) { throw std::runtime_error("Failed to open file"); } } ~FileHandler() { if (file_) fclose(file_); } // 禁用拷贝构造和赋值 FileHandler(const FileHandler&) = delete; FileHandler& operator=(const FileHandler&) = delete; private: FILE* file_; };

4.2 异常安全保证的三个级别

1. 基本保证：发生异常时，不泄露资源，对象处于有效状态
2. 强保证：操作要么完全成功，要么回滚到操作前的状态
3. 不抛出保证：操作保证不会抛出任何异常

4.3 使用swap实现强异常安全

class StringArray { public: void addString(const std::string& str) { std::vector<std::string> newData = data_; // 拷贝 newData.push_back(str); // 修改拷贝 // 如果上面操作成功，再交换 data_.swap(newData); // 不抛出异常 } private: std::vector<std::string> data_; };

5. 异常处理的性能考量

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

1. 代码膨胀：编译器需要生成额外的异常处理表
2. 抛出时的开销：构造异常对象和栈展开(stack unwinding)过程
3. 零开销原则：不抛出异常时没有额外开销

性能建议：在性能关键路径上，考虑使用错误码替代异常。但对于大多数应用场景，异常处理的性能影响可以忽略不计。

6. 常见陷阱与最佳实践

6.1 不要滥用异常

以下情况不应使用异常：

• 正常的控制流（使用if-else代替）
• 频繁发生的错误（如用户输入验证）
• 跨模块边界（特别是跨DLL/so边界）

6.2 异常安全的自定义类

设计类时应考虑：

class SafeResource { public: SafeResource() : ptr_(new int[100]) {} ~SafeResource() { delete[] ptr_; } // 拷贝构造和赋值需要特别注意异常安全 SafeResource(const SafeResource& other) : ptr_(new int[100]) { std::copy(other.ptr_, other.ptr_ + 100, ptr_); } SafeResource& operator=(SafeResource other) { swap(*this, other); return *this; } friend void swap(SafeResource& a, SafeResource& b) noexcept { std::swap(a.ptr_, b.ptr_); } private: int* ptr_; };

6.3 多线程环境下的异常处理

在多线程中，未被捕获的异常会导致程序终止。C++11引入了std::future来处理跨线程异常：

#include <future> #include <iostream> void worker() { throw std::runtime_error("Error in worker thread"); } int main() { auto future = std::async(std::launch::async, worker); try { future.get(); // 会抛出worker中的异常 } catch (const std::exception& e) { std::cerr << "Caught exception: " << e.what() << std::endl; } }

7. C++17/20中的异常处理改进

7.1 std::terminate_handler

可以自定义未捕获异常的处理方式：

#include <exception> #include <iostream> void myTerminate() { std::cerr << "Uncaught exception! Terminating..." << std::endl; std::abort(); } int main() { std::set_terminate(myTerminate); throw 42; // 没有catch块，会调用myTerminate }

7.2 std::uncaught_exceptions (C++17)

返回当前未被捕获的异常数量，用于实现更复杂的资源管理：

class Transaction { public: Transaction() : count_(std::uncaught_exceptions()) {} ~Transaction() { if (std::uncaught_exceptions() > count_) { rollback(); // 只有在异常退出时才回滚 } else { commit(); // 正常退出时提交 } } private: int count_; void commit() { /*...*/ } void rollback() { /*...*/ } };

7.3 协程中的异常处理 (C++20)

协程有自己独特的异常传播机制：

#include <coroutine> #include <exception> struct Task { struct promise_type { std::exception_ptr exception; auto get_return_object() { return Task{}; } auto initial_suspend() { return std::suspend_never{}; } auto final_suspend() noexcept { return std::suspend_never{}; } void unhandled_exception() { exception = std::current_exception(); } void return_void() {} }; }; Task coroutineThatThrows() { throw std::runtime_error("Error in coroutine"); co_return; }

8. 实际项目中的异常处理策略

8.1 日志记录策略

良好的异常处理应包含详细的日志记录：

try { riskyOperation(); } catch (const std::exception& e) { logError("Operation failed", e.what(), __FILE__, __LINE__); throw; // 重新抛出 } void logError(const char* msg, const char* details, const char* file, int line) { std::cerr << "[" << file << ":" << line << "] " << msg << ": " << details << std::endl; }

8.2 异常转换模式

在不同抽象层之间转换异常类型：

void highLevelAPI() { try { lowLevelOperation(); } catch (const LowLevelException& e) { throw HighLevelException("Operation failed", e); } }

8.3 资源清理的最终手段

即使异常发生也要确保资源释放：

void processFile() { FILE* file = fopen("data.txt", "r"); if (!file) throw std::runtime_error("File open failed"); try { // 处理文件内容 } catch (...) { fclose(file); // 确保文件关闭 throw; // 重新抛出异常 } fclose(file); // 正常情况下的关闭 }

9. 异常处理单元测试

确保异常处理逻辑的正确性：

#define CATCH_CONFIG_MAIN #include <catch2/catch.hpp> TEST_CASE("Division by zero throws") { REQUIRE_THROWS_AS(divide(1, 0), std::invalid_argument); REQUIRE_THROWS_WITH(divide(1, 0), "Division by zero"); } double divide(double a, double b) { if (b == 0) throw std::invalid_argument("Division by zero"); return a / b; }

10. 从C++异常看其他语言的异常处理

虽然本文聚焦C++，但对比其他语言也有启发：

1. Java：强制检查异常(checked exceptions) vs C++的非强制
2. Python：异常作为常规控制流的一部分
3. Go：没有传统异常机制，使用error返回值
4. Rust：Result<T, E>和panic!机制

C++的设计哲学是"不为不使用的内容付费"，因此异常处理是可选的，且零开销（当不抛出异常时）。