C++中异常正确抛出、处理及大型项目多异常管理问询

嘿，很高兴能帮你解决C++异常处理的问题，咱们一个一个来聊：

首先，抛出异常用throw关键字，处理异常则依赖try-catch块。这里的核心是自定义异常要基于C++标准异常体系，既能和标准库行为对齐，又能实现精准的类型区分。

举个实操例子：

• 先定义自定义异常类，推荐继承std::runtime_error（它自带字符串存储，实现了what()方法）：

#include <stdexcept>
#include <string>

// 针对MySQL场景的自定义异常
class MySQLException : public std::runtime_error {
public:
    explicit MySQLException(const std::string& msg) 
        : std::runtime_error(msg) {}
    
    // 可以额外添加业务相关的信息，比如错误码
    int getDbErrorCode() const { return db_error_code_; }
    void setDbErrorCode(int code) { db_error_code_ = code; }
private:
    int db_error_code_ = 0;
};

• 在底层驱动中抛出特定异常：

void executeSql(const std::string& sql) {
    if (/* 检测到非法表名 */) {
        MySQLException e("非法表：invalid_table");
        e.setDbErrorCode(1146); // MySQL的"表不存在"错误码
        throw e;
    }
    // 其他逻辑...
}

• 上层捕获特定异常时，要注意子类在前、父类在后的顺序（catch会匹配第一个类型兼容的块），并且用const引用捕获避免拷贝和对象切片：

int main() {
    try {
        executeSql("SELECT * FROM invalid_table");
    } catch (const MySQLException& e) { // 优先捕获特定业务异常
        std::cerr << "MySQL错误：" << e.what() << "，错误码：" << e.getDbErrorCode() << 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;
    }
    return 0;
}

你提到的“底层抛MySQLException但顶层变成std::runtime_error”的问题，大概率是中间层捕获异常后，重新构造了一个std::runtime_error抛出（比如throw std::runtime_error(e.what());），这直接丢失了原始异常的类型信息。下面结合你的场景，聊聊大型项目的异常管理方案：

先解决你的具体问题：保留原始异常类型 #

如果中间层只需要传递异常而不处理，绝对不要重新构造新异常，而是用throw;（不带参数）原样抛出：

// 中间代理函数
void proxySql(const std::string& sql) {
    try {
        executeSql(sql);
    } catch (...) {
        // 可以在这里加日志，再传递给上层
        std::cerr << "[中间层] 捕获到数据库异常，向上传递" << std::endl;
        throw; // 完全保留原始异常类型，不会变成std::runtime_error
    }
}

如果必须转换异常类型（比如统一包装业务错误），可以用异常嵌套（C++11及以上支持），保留异常链：

#include <exception>

void proxySql(const std::string& sql) {
    try {
        executeSql(sql);
    } catch (const MySQLException& e) {
        // 嵌套原始异常，上层可以解析到真实类型
        std::throw_with_nested(std::runtime_error("数据库查询失败：" + std::string(e.what())));
    }
}

// 解析嵌套异常的工具函数
void printNestedException(const std::exception& e, int indent = 0) {
    std::cerr << std::string(indent, ' ') << "异常信息：" << e.what() << std::endl;
    try {
        std::rethrow_if_nested(e);
    } catch (const std::exception& nested_e) {
        printNestedException(nested_e, indent + 2);
    } catch (...) {}
}

// 上层调用示例
int main() {
    try {
        proxySql("SELECT * FROM invalid_table");
    } catch (const std::runtime_error& e) {
        printNestedException(e);
        // 还可以尝试还原原始异常类型
        try {
            std::rethrow_if_nested(e);
        } catch (const MySQLException& me) {
            std::cerr << "原始MySQL错误码：" << me.getDbErrorCode() << std::endl;
        }
    }
}

大型项目通用的异常管理策略 #

1. 构建层级化的异常体系
   不要零散定义异常类，而是建立继承树，方便按粒度捕获：

   std::exception
       └── DBException（所有数据库异常基类）
           ├── MySQLException
           │   ├── TableNotFoundException
           │   └── ColumnNotFoundException
           └── PostgreSQLException
               └── ConnectionRefusedException
   

   上层代码可以灵活选择：比如捕获DBException&处理所有数据库错误，或者捕获TableNotFoundException&处理特定的表不存在场景。

2. 让异常携带足够上下文
   自定义异常除了错误消息，还应该包含：

   • 业务错误码（比如MySQL原生错误码）
   • 出错的SQL语句、请求ID
   • 调用栈信息（C++23可用std::stacktrace，低版本可以用第三方库）
     这些信息能极大降低调试难度。

3. 统一异常处理入口
   尽量让异常向上传递到顶层（比如客户端主循环、服务端请求入口），在统一位置做：

   • 完整日志记录（包含所有异常上下文）
   • 用户友好的错误提示（比如给前端返回JSON，给桌面客户端弹提示）
   • 资源清理（比如关闭数据库连接、释放文件句柄）

4. 谨慎使用catch(...)
   catch(...)会捕获所有异常（包括非标准异常），除非是为了防止服务崩溃，否则不要轻易使用。如果用了，一定要做致命错误日志、优雅退出，绝对不能吞掉异常（什么都不做）。

内容的提问来源于stack exchange，提问作者Brighter side