C++ 异常重新抛出

什么是异常重新抛出？

异常重新抛出是C++异常处理机制中的一个重要特性，它允许你在捕获异常后，将同一个异常再次抛出，使异常继续沿着调用栈向上传播。这种技术特别适用于你需要在当前函数中处理异常，同时又希望调用者知道发生了异常的情况。

异常重新抛出的基本语法非常简单，只需在catch块中使用不带参数的throw语句：

cpp

try {
    // 可能抛出异常的代码
} catch (ExceptionType& e) {
    // 部分处理异常
    // ...
    throw; // 重新抛出当前捕获的异常
}

备注

重新抛出的是原始异常对象，保留了原始异常的所有信息，包括其类型和内容。这一点与创建新异常对象并抛出不同。

异常重新抛出的工作原理

当你在catch块中使用无参数的throw语句时，C++会重新抛出当前正在处理的异常对象。重要的是，它会保留原始异常的动态类型和所有状态，这与创建新异常对象不同。

让我们来看一个基本示例：

cpp

#include <iostream>
#include <stdexcept>

void function_B() {
    try {
        throw std::runtime_error("原始异常");
    } catch (const std::exception& e) {
        std::cout << "在function_B中捕获: " << e.what() << std::endl;
        throw; // 重新抛出当前异常
    }
}

void function_A() {
    try {
        function_B();
    } catch (const std::exception& e) {
        std::cout << "在function_A中捕获: " << e.what() << std::endl;
    }
}

int main() {
    function_A();
    return 0;
}

输出结果：

在function_B中捕获: 原始异常
在function_A中捕获: 原始异常

在这个例子中，function_B抛出了一个运行时异常，然后捕获它，打印信息后重新抛出。function_A随后捕获了这个异常并处理它。

为什么要使用异常重新抛出？

异常重新抛出在以下场景特别有用：

1. 部分处理异常：当前函数可以部分处理异常，但完全解决问题需要调用者的参与。
2. 日志记录和调试：在不中断异常传播的情况下记录异常信息。
3. 资源清理：确保在异常处理过程中释放资源，同时让调用者知道发生了问题。
4. 异常转换：捕获一种类型的异常，可能时将其转换成另一种类型再抛出。

异常重新抛出与创建新异常的区别

重新抛出异常与创建新异常并抛出有很大区别：

cpp

// 重新抛出原始异常
catch (const std::exception& e) {
    // 处理
    throw; // 保留原始类型和所有信息
}

// 创建并抛出新异常
catch (const std::exception& e) {
    // 处理
    throw std::runtime_error("新异常"); // 丢失原始类型和信息
}

重新抛出的主要优势是保留了原始异常的完整信息，包括：

• 原始异常的确切类型（即使是派生类）
• 异常对象的所有内部状态
• 堆栈跟踪信息（在支持的环境中）

异常重新抛出的高级用法

1. 在嵌套的异常处理中重新抛出

cpp

#include <iostream>
#include <stdexcept>

void process() {
    try {
        try {
            throw std::runtime_error("内部异常");
        } catch (const std::exception& e) {
            std::cout << "内部捕获: " << e.what() << std::endl;
            throw; // 重新抛出到外部try块
        }
    } catch (const std::exception& e) {
        std::cout << "外部捕获: " << e.what() << std::endl;
    }
}

int main() {
    process();
    return 0;
}

输出结果：

内部捕获: 内部异常
外部捕获: 内部异常

2. 异常转换与重新抛出

有时你可能想捕获一种类型的异常，但以不同的类型重新抛出：

cpp

#include <iostream>
#include <stdexcept>
#include <string>

class DatabaseException : public std::runtime_error {
public:
    DatabaseException(const std::string& message) 
        : std::runtime_error(message) {}
};

void queryDatabase() {
    // 模拟数据库操作失败
    throw std::runtime_error("SQL语法错误");
}

void processUserRequest() {
    try {
        queryDatabase();
    } catch (const std::exception& e) {
        // 记录原始异常
        std::cerr << "数据库错误: " << e.what() << std::endl;
        
        // 转换为应用级异常
        throw DatabaseException("数据库查询失败，请稍后再试");
    }
}

int main() {
    try {
        processUserRequest();
    } catch (const DatabaseException& e) {
        std::cout << "向用户显示: " << e.what() << std::endl;
    }
    return 0;
}

输出结果：

数据库错误: SQL语法错误
向用户显示: 数据库查询失败，请稍后再试

这种模式特别适用于将底层技术细节转换为更友好的用户消息。

3. 在资源管理中使用异常重新抛出

cpp

#include <iostream>
#include <fstream>
#include <stdexcept>

void processFile(const std::string& filename) {
    std::ifstream file;
    
    try {
        file.open(filename);
        if (!file.is_open()) {
            throw std::runtime_error("无法打开文件");
        }
        
        // 处理文件...
        throw std::runtime_error("文件处理过程中出错");
        
    } catch (const std::exception& e) {
        // 确保文件关闭
        if (file.is_open()) {
            std::cout << "关闭文件..." << std::endl;
            file.close();
        }
        
        // 重新抛出异常
        throw;
    }
}

int main() {
    try {
        processFile("不存在的文件.txt");
    } catch (const std::exception& e) {
        std::cout << "主函数捕获: " << e.what() << std::endl;
    }
    return 0;
}

输出结果：

主函数捕获: 无法打开文件

在这个例子中，无论处理文件过程中出现什么异常，都会先确保文件被正确关闭，然后再将异常传递给调用者。

实际应用场景

场景1：中间件异常处理

在Web服务器、API网关或其他中间件组件中，异常重新抛出特别有用：

cpp

void RequestMiddleware::processRequest(Request& request) {
    try {
        // 尝试处理请求
        nextMiddleware.process(request);
    } catch (const AuthenticationException& e) {
        // 记录认证失败
        logger.logError("认证失败: " + std::string(e.what()));
        throw; // 让应用决定如何响应认证错误
    } catch (const std::exception& e) {
        // 所有其他异常都记录
        logger.logError("请求处理错误: " + std::string(e.what()));
        throw; // 向上传递异常
    }
}

场景2：清理与事务处理

在数据库操作中，确保事务的完整性同时传递异常：

cpp

void DatabaseManager::executeTransaction(const std::vector<Query>& queries) {
    beginTransaction();
    
    try {
        for (const auto& query : queries) {
            execute(query);
        }
        commitTransaction();
    } catch (...) { // 捕获所有异常
        std::cout << "事务出错，执行回滚..." << std::endl;
        rollbackTransaction();
        throw; // 重新抛出异常
    }
}

最佳实践

1. 明确目的：只有当你确实需要在不同层次处理同一个异常时才使用重新抛出。

2. 避免过度捕获：不要捕获你不打算处理的异常类型。

3. 维护异常语义：重新抛出时保持异常的原始语义，或使用更具体的异常类型。

4. 日志记录：在重新抛出前记录异常信息，有助于调试。

5. 资源管理：使用RAII（资源获取即初始化）和智能指针，减少手动资源管理的需要。

cpp

// 使用RAII代替手动资源管理
void betterFileProcess(const std::string& filename) {
    try {
        // 文件会在析构函数中自动关闭
        std::ifstream file(filename);
        if (!file.is_open()) {
            throw std::runtime_error("无法打开文件");
        }
        
        // 处理文件...
        
    } catch (const std::exception& e) {
        std::cout << "记录错误: " << e.what() << std::endl;
        throw; // 重新抛出，但不需要手动关闭文件
    }
}

注意事项

警告

空的throw语句只能在catch块中使用。在catch块外使用将导致调用std::terminate()。

cpp

void incorrectFunction() {
    throw; // 错误：不在异常处理器内
}

注意

如果在多个catch块中重新抛出异常，确保理解异常的传播路径。复杂的重新抛出可能会使代码难以理解和维护。

总结

异常重新抛出是C++异常处理机制中强大而灵活的特性，它允许你在捕获异常后继续传播它。重新抛出异常的主要优点是保留了原始异常的所有信息，包括类型和状态。

异常重新抛出特别适用于：

• 部分处理异常的情况
• 需要记录日志但不完全处理异常的场景
• 确保资源清理的同时不中断异常传播
• 在中间件或多层架构中的异常处理

正确使用异常重新抛出可以构建更健壮、更可维护的错误处理系统，但需要清晰理解异常的传播路径和处理职责。

练习

1. 编写一个函数，它打开一个文件，读取内容，但在遇到异常时确保文件被关闭，然后重新抛出异常。

2. 创建一个自定义异常类层次结构，并编写一个程序演示如何在不同层次的函数调用中捕获和重新抛出这些异常。

3. 实现一个简单的资源管理类，它在析构函数中释放资源，并演示如何与异常重新抛出结合使用。

4. 编写一个程序，展示如何在一个函数中捕获一种类型的异常，将其转换为另一种类型然后抛出。

扩展阅读

• C++标准库中的异常类层次结构
• 异常安全保证的不同级别
• C++17中的std::exception_ptr和std::current_exception
• C++中的嵌套异常处理

祝你学习愉快！掌握异常重新抛出技术将帮助你编写更健壮的C++程序。