[学习]浅谈C++异常处理（代码示例）_c++ 嵌套异常处理机制-优快云博客

本文链接：https://blog.youkuaiyun.com/jz_ddk/article/details/148214367

浅谈C++异常处理

一、异常处理基础

1.异常的概念与作用

异常是程序在运行时发生的意外或错误情况（如除零错误、内存不足、文件不存在等），它打破了正常的程序执行流程。异常处理机制允许开发者：

分离错误处理代码：将正常逻辑与错误处理解耦，提升代码可读性
跨函数传递错误：异常可沿调用栈向上传递，无需每层函数显式检查错误
标准化错误报告：通过异常类型和消息规范错误信息

2.C++异常处理机制（`try`、`catch`、`throw`）

throw：当检测到错误时，用throw抛出异常对象（如内置类型、自定义类或标准库异常）
- 示例：throw 42;（抛出整型）或 throw std::out_of_range("Index invalid");
try：包裹可能引发异常的代码块
catch：捕获并处理特定类型的异常，支持多级捕获（类似switch-case的匹配机制）

3.基本语法示例

#include <iostream>
#include <stdexcept> // 包含标准异常类

double divide(int a, int b) {
    if (b == 0) {
        throw std::runtime_error("Division by zero"); // 抛出运行时错误
    }
    return static_cast<double>(a) / b;
}

int main() {
    try {
        std::cout << divide(10, 2) << std::endl;  // 正常执行
        std::cout << divide(5, 0) << std::endl;   // 触发异常
    } catch (const std::runtime_error& e) {       // 捕获特定异常
        std::cerr << "[ERROR] " << e.what() << std::endl;
    } catch (...) {                               // 捕获所有未处理的异常
        std::cerr << "Unknown exception occurred" << std::endl;
    }
    return 0;
}

输出示例：

5
[ERROR] Division by zero

应用场景：

文件操作失败处理

当使用std::ifstream打开或读取文件时，若文件不存在、权限不足或格式错误，会抛出std::ifstream::failure异常。例如：

try {
    std::ifstream file("data.txt");
    if (!file) throw std::ifstream::failure("Failed to open file");
    // 文件读取操作...
} catch (const std::ifstream::failure& e) {
    std::cerr << "File error: " << e.what() << std::endl;
}

典型场景：配置文件加载、日志文件读取或数据导入时验证文件有效性。

动态内存分配失败处理
- 使用new分配大量内存时，若系统内存不足会抛出std::bad_alloc。例如：
```
try {
    int* large_array = new int[1000000000]; // 可能分配失败
} catch (const std::bad_alloc& e) {
    std::cerr << "Memory allocation failed: " << e.what() << std::endl;
}
```
- 优化建议：在嵌入式系统或高性能计算中，可预先检查可用内存或使用std::nothrow替代方案。

自定义异常处理业务逻辑

定义继承自std::exception的异常类（如InvalidUserInputException），用于验证用户输入。例如：

class InvalidUserInputException : public std::exception {
public:
    const char* what() const noexcept override {
        return "User input contains invalid characters";
    }
};

void validateInput(const std::string& input) {
    if (input.find('@') == std::string::npos) {
        throw InvalidUserInputException();
    }
}

扩展场景：电商系统中校验订单金额非负，或游戏开发中检查玩家非法操作。

最佳实践：

优先捕获具体异常类型（如std::bad_alloc而非通用std::exception）。
在异常处理中记录上下文信息（如文件名、输入值）以便调试。
资源管理类（如数据库连接）应在析构函数中释放资源，而非依赖异常处理。

二、标准异常类

C++标准库提供了丰富的异常类体系，主要通过std::exception基类及其派生类来实现异常处理机制。这些异常类通常包含在<exception>头文件中，为开发者提供了标准化的异常处理方式。

1.常见标准异常类：

std::exception
所有标准异常类的基类，提供what()虚函数用于获取异常描述信息。
std::runtime_error
- 用于表示程序运行时发生的错误（如文件不存在、网络连接失败等）
- 典型派生类：
  - std::overflow_error - 算术运算溢出
  - std::underflow_error - 算术运算下溢
  - std::range_error - 超出有效范围
std::logic_error
- 用于表示程序逻辑错误（如无效参数、违反前置条件等）
- 典型派生类：
  - std::invalid_argument - 无效参数
  - std::out_of_range - 超出允许范围
  - std::length_error - 超出最大允许长度

2.自定义异常类的实现

在实际开发中，我们经常需要创建特定于应用的异常类。通过继承std::exception或其派生类，可以保持与标准异常处理机制的一致性。

#include <exception>
#include <string>

class MyCustomException : public std::exception {
private:
    std::string error_msg;  // 存储详细的错误信息
    
public:
    // 构造函数，允许传入自定义错误信息
    explicit MyCustomException(const std::string& msg) 
        : error_msg(msg) {}
    
    // 重写what()方法，返回错误描述
    const char* what() const noexcept override {
        return error_msg.c_str();
    }
    
    // 示例用法：
    // throw MyCustomException("File processing failed: invalid format");
};

自定义异常类的典型应用场景：

文件处理异常（如文件格式不符、权限不足）
网络通信异常（如连接超时、协议错误）
业务逻辑异常（如交易金额超限、用户状态异常）

实现建议：

继承自std::exception或其标准派生类
提供详细的错误信息存储机制
确保what()方法不会抛出异常（使用noexcept）
考虑添加额外的错误代码或上下文信息字段

三、异常安全与最佳实践

1. RAII（资源获取即初始化）与异常安全

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期管理资源的核心编程范式。通过将资源的获取与对象的构造绑定，资源的释放与对象的析构绑定，确保即使在异常发生时资源也能被正确释放，避免内存泄漏或资源泄露。

典型应用场景：

文件操作：使用 std::ifstream 或 std::ofstream 封装文件句柄，析构时自动关闭文件。
动态内存管理：通过 std::unique_ptr 或 std::shared_ptr 管理堆内存，无需手动 delete。
锁管理：利用 std::lock_guard 在作用域内自动加锁和解锁，避免死锁。

示例代码：

void processFile(const std::string& filename) {
    std::ifstream file(filename); // 构造函数打开文件
    if (!file.is_open()) {
        throw std::runtime_error("Failed to open file");
    }
    // 文件操作...（若此处抛出异常，file 析构时会自动关闭文件）
} // 作用域结束，file 析构自动关闭文件

2. `noexcept` 关键字的作用与使用场景

noexcept 是 C++11 引入的关键字，用于显式声明函数不会抛出异常。合理使用可以优化性能，并为编译器提供更多优化机会。

主要作用：

性能优化：标记为 noexcept 的函数可能触发移动语义而非拷贝（如 std::vector 的重新分配）。
契约声明：明确告知调用者该函数不会抛出异常，简化错误处理逻辑。

适用场景：

析构函数、移动构造函数、移动赋值运算符等必须声明为 noexcept（标准库容器依赖此保证）。
简单工具函数（如数学计算）、资源释放逻辑等无异常风险的函数。

示例：

class Buffer {
public:
    Buffer(Buffer&& other) noexcept // 移动构造函数不抛出异常
        : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr;
    }
    ~Buffer() noexcept { delete[] data_; } // 析构函数通常不抛出异常
private:
    int* data_;
    size_t size_;
};

3. 避免异常滥用与性能影响

异常机制虽然强大，但滥用可能导致性能下降或代码可维护性降低。需注意以下原则：

最佳实践：

避免频繁抛出异常：异常处理成本较高，高频场景（如循环内）建议改用错误码或状态检查。
异常 vs 错误码：
- 使用异常处理不可恢复的错误（如内存不足、文件损坏）。
- 使用错误码处理预期内的错误（如用户输入无效）。
禁用异常的场景：嵌入式系统等对运行时开销敏感的环境，可通过编译选项（如 -fno-exceptions）禁用异常。

性能对比示例：

// 低效：在热路径中抛出异常
for (int i = 0; i < 10000; ++i) {
    try {
        riskyOperation();
    } catch (...) { /* 处理 */ }
}

// 高效：提前检查避免异常
for (int i = 0; i < 10000; ++i) {
    if (canPerformOperation()) { // 预先验证
        safeOperation();
    }
}

总结：异常安全的核心是资源管理确定性与异常使用克制性，结合 RAII 与 noexcept 可显著提升代码健壮性。

四、高级异常处理技术

1. 嵌套异常（`std::nested_exception`）

嵌套异常允许异常对象包含另一个异常，形成异常链，便于捕获和调试多层异常。这在复杂系统中特别有用，例如框架或库的调用栈中可能抛出多种异常的场景。

示例代码：

#include <exception>
#include <iostream>
#include <stdexcept>

void handle_nested_exception(const std::exception& e) {
    try {
        std::rethrow_if_nested(e); // 尝试重新抛出嵌套异常  
    } catch (const std::exception& nested) {
        std::cerr << "Nested Exception: " << nested.what() << std::endl;
        handle_nested_exception(nested); // 递归处理嵌套异常  
    }
}

int main() {
    try {
        try {
            throw std::runtime_error("Primary error");
        } catch (...) {
            std::throw_with_nested(std::logic_error("Wrapper error"));
        }
    } catch (const std::exception& e) {
        std::cerr << "Outer Exception: " << e.what() << std::endl;
        handle_nested_exception(e);
    }
    return 0;
}

应用场景：

在多层调用的框架中，捕获底层异常并附加高层上下文信息。
日志记录时保留完整的异常链，便于问题溯源。

2. 异常传播与重新抛出（`throw;`）

在异常处理块中，使用 throw; 可以重新抛出当前捕获的异常，保持原始异常类型和调用栈信息。

关键点：

仅当在 catch 块内使用时有效，否则行为未定义。
适用于需要部分处理异常但最终仍由上级调用者处理的场景。

示例代码：

void process_data() {
    try {
        // 可能抛出异常的代码  
        throw std::runtime_error("Data processing failed");
    } catch (...) {
        std::cerr << "Partial handling in process_data()" << std::endl;
        throw; // 重新抛出  
    }
}

int main() {
    try {
        process_data();
    } catch (const std::runtime_error& e) {
        std::cerr << "Handled in main(): " << e.what() << std::endl;
    }
    return 0;
}

典型场景：

中间层函数需要清理资源（如关闭文件），但异常仍需传递给调用者。
实现异常过滤器，选择性重新抛出特定异常类型。

3. 异常处理在多线程环境中的注意事项

多线程中未捕获的异常会导致程序终止（C++11 后通过 std::terminate），需显式处理线程内异常。

解决方案：

使用 try-catch 包裹线程入口函数：

void thread_worker() {
    try {
        // 线程逻辑  
    } catch (const std::exception& e) {
        std::cerr << "Thread error: " << e.what() << std::endl;
    }
}

传递异常到主线程（通过 std::promise 或全局变量）：

std::promise<void> promise;
std::thread t([&promise] {
    try {
        // 线程逻辑  
        promise.set_value();
    } catch (...) {
        promise.set_exception(std::current_exception());
    }
});
try {
    promise.get_future().get(); // 主线程捕获异常  
} catch (const std::exception& e) {
    std::cerr << "Main thread caught: " << e.what() << std::endl;
}
t.join();

注意事项：

避免跨线程直接 throw，因栈展开可能不同步。
使用 std::exception_ptr 存储和跨线程传递异常对象。

五、实际应用案例

1. 文件操作中的异常处理

文件操作是编程中常见的场景，但可能会遇到文件不存在、权限不足或磁盘空间不足等问题。合理的异常处理可以避免程序崩溃，并提供友好的错误提示。

示例代码：读取文件内容并处理异常

def read_file(file_path):
    try:
        with open(file_path, 'r', encoding='utf-8') as file:
            content = file.read()
            print(f"文件内容读取成功：\n{content}")
    except FileNotFoundError:
        print(f"错误：文件 '{file_path}' 不存在，请检查路径。")
    except PermissionError:
        print(f"错误：没有权限访问文件 '{file_path}'。")
    except UnicodeDecodeError:
        print(f"错误：文件 '{file_path}' 编码格式不支持，请指定正确的编码。")
    except Exception as e:
        print(f"未知错误：{str(e)}")

# 调用示例
read_file("example.txt")

应用场景

读取配置文件时，避免因文件缺失导致程序中断。
批量处理文件时，记录错误文件路径并跳过，不影响后续文件操作。

2. 网络编程中的异常管理

网络请求可能因连接超时、服务器错误或数据格式问题而失败。异常管理能提高程序的健壮性，尤其是在高并发或分布式系统中。

示例代码：HTTP请求异常处理

import requests

def fetch_data(url):
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status()  # 检查HTTP状态码
        return response.json()
    except requests.exceptions.Timeout:
        print(f"请求超时：服务器未在5秒内响应（URL: {url}）。")
    except requests.exceptions.HTTPError as e:
        print(f"HTTP错误：状态码 {e.response.status_code}（URL: {url}）。")
    except requests.exceptions.JSONDecodeError:
        print(f"数据格式错误：返回内容非JSON格式（URL: {url}）。")
    except Exception as e:
        print(f"网络请求失败：{str(e)}")

# 调用示例
data = fetch_data("https://api.example.com/data")

应用场景

API调用时，处理服务器返回的错误状态码（如404、500）。
爬虫程序中跳过失效链接，避免因单次请求失败终止任务。

3. 大型项目中的异常策略设计

在大型项目中，异常处理需要统一策略，包括日志记录、错误分类和恢复机制。常见的做法包括自定义异常类和全局异常拦截。

示例代码：自定义异常与全局处理

# 自定义异常类
class DatabaseConnectionError(Exception):
    """数据库连接失败时抛出"""
    pass

class InvalidInputError(Exception):
    """用户输入非法时抛出"""
    pass

# 全局异常处理器
def handle_exceptions(func):
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except DatabaseConnectionError as e:
            log_error(f"数据库错误：{str(e)}")
            show_user_message("系统繁忙，请稍后重试。")
        except InvalidInputError as e:
            log_error(f"输入错误：{str(e)}")
            show_user_message("请输入有效数据。")
        except Exception as e:
            log_error(f"未捕获的异常：{str(e)}")
            show_user_message("系统发生未知错误。")
    return wrapper

# 使用装饰器管理异常
@handle_exceptions
def process_user_data(user_input):
    if not user_input.isdigit():
        raise InvalidInputError("输入必须为数字")
    # 模拟数据库操作
    if not connect_database():
        raise DatabaseConnectionError("无法连接MySQL")

# 辅助函数
def log_error(message):
    with open("error.log", "a") as f:
        f.write(f"[ERROR] {message}\n")

def show_user_message(message):
    print(message)