C++通过多个catch块捕获不同异常类型，按从具体到通用的顺序匹配，确保精确处理；catch(...)用于捕获未知异常，适合作为最后防线进行日志记录或资源清理，避免程序崩溃。
C++捕获多个异常类型主要通过使用多个
catch块，每个块处理一种特定的异常类型，或者使用一个通用的
catch(...)块来捕获所有未知或未明确处理的异常。理解它们的优先级和适用场景，是写出健壮C++代码的关键。
解决方案
在C++中处理异常，特别是当你的代码可能抛出多种不同类型的错误时，我们需要一种机制来区分和响应这些错误。最直接也是最常用的方法，就是堆叠
catch块。
你可以为每一种你预期可能出现的异常类型编写一个
catch块。例如，你可能有一个文件操作失败的异常，一个网络连接超时的异常，或者一个内存分配不足的异常。代码看起来会是这样：
#include#include // 包含标准异常类，如std::runtime_error, std::logic_error // 假设我们有自定义异常 class FileIOException : public std::runtime_error { public: FileIOException(const std::string& msg) : std::runtime_error(msg) {} }; class NetworkException : public std::runtime_error { public: NetworkException(const std::string& msg) : std::runtime_error(msg) {} }; void mightThrowDifferentExceptions(int type) { if (type == 1) { throw FileIOException("文件读取失败！"); } else if (type == 2) { throw NetworkException("网络连接超时！"); } else if (type == 3) { throw std::bad_alloc(); // 标准库的内存分配异常 } else if (type == 4) { throw std::runtime_error("未知运行时错误！"); } else { throw "一个C风格字符串异常"; // 尽量避免，但确实可能发生 } } int main() { try { mightThrowDifferentExceptions(2); // 尝试抛出网络异常 // mightThrowDifferentExceptions(1); // 尝试抛出文件异常 // mightThrowDifferentExceptions(3); // 尝试抛出内存异常 // mightThrowDifferentExceptions(4); // 尝试抛出运行时异常 // mightThrowDifferentExceptions(5); // 尝试抛出C风格字符串异常 } catch (const FileIOException& e) { std::cerr << "捕获到文件IO异常: " << e.what() << std::endl; // 这里可以进行文件相关的恢复操作 } catch (const NetworkException& e) { std::cerr << "捕获到网络异常: " << e.what() << std::endl; // 这里可以尝试重新连接或通知用户 } catch (const std::bad_alloc& e) { std::cerr << "捕获到内存分配异常: " << e.what() << std::endl; // 尝试释放一些内存，或者优雅地退出 } catch (const std::runtime_error& e) { // 这个catch块会捕获所有继承自std::runtime_error的异常， // 包括我们的FileIOException和NetworkException，如果它们没有被更早的catch块捕获 std::cerr << "捕获到通用运行时异常: " << e.what() << std::endl; } catch (const std::exception& e) { // 这个catch块会捕获所有继承自std::exception的异常 std::cerr << "捕获到标准库异常: " << e.what() << std::endl; } catch (...) { // 捕获所有其他未知类型的异常 std::cerr << "捕获到未知异常类型！" << std::endl; // 只能做一些通用的清理工作，无法获取异常的具体信息 } std::cout << "程序继续执行..." << std::endl; return 0; }
我个人在写代码时，更倾向于明确捕获已知异常，
catch(...)通常作为最后的防线，用来记录日志或确保程序优雅退出，而不是进行复杂的错误恢复。这种分层处理的方式，能让代码的错误处理逻辑更清晰、更可控。
立即学习“C++免费学习笔记（深入）”；
为什么捕获异常的顺序很重要？
这是一个非常关键的问题，我见过不少新手在这里栽跟头，调试起来挺头疼的，因为异常可能被一个不那么精确的
catch吞掉了。在C++中，当一个异常被抛出时，系统会从
try块后的第一个
catch块开始，按照它们在代码中出现的顺序进行匹配。一旦找到一个匹配的
catch块（即该
catch块能处理抛出的异常类型，或者其基类），就会执行该
catch块中的代码，而后续的
catch块则会被跳过。
这意味着，如果你有一个基类异常（例如
std::exception）和一个派生类异常（例如
std::runtime_error或我们自定义的
FileIOException），你必须把派生类异常的
catch块放在基类异常的
catch块之前。如果顺序颠倒，派生类异常就会被基类
catch块捕获，导致你无法执行针对特定异常的更精细处理。
举个例子：
#include#include class DerivedException : public std::runtime_error { public: DerivedException(const std::string& msg) : std::runtime_error(msg) {} }; void func() { throw DerivedException("这是一个派生类异常"); } int main() { try { func(); } catch (const std::runtime_error& e) { // 基类异常先捕获 std::cerr << "捕获到基类异常: " << e.what() << std::endl; } catch (const DerivedException& e) { // 派生类异常永远不会被捕获到这里 std::cerr << "捕获到派生类异常: " << e.what() << std::endl; } return 0; }
在这个例子中，
DerivedException是一个
std::runtime_error，所以它会被第一个
catch (const std::runtime_error& e)块捕获。第二个
catch (const DerivedException& e)块将永远不会被执行到，这显然不是我们想要的结果。正确的顺序应该是将
DerivedException的
catch块放在
std::runtime_error之前。
因此，记住这个原则：从最具体的异常类型到最通用的异常类型，这是编写多
catch块时必须遵循的黄金法则。
如何优雅地处理无法识别的异常（catch(...)
的正确姿势）？
catch(...)是一个非常强大的工具，它能捕获任何类型的异常，包括那些你没有预料到、甚至不是继承自
std::exception的异常（比如C风格的字符串字面量或原始类型）。然而，它的强大也伴随着局限性：你无法在
catch(...)块中直接访问异常对象，这意味着你不知道具体抛出了什么。
正因如此，
catch(...)通常不用于恢复程序状态，而是作为最后的防线。我通常会在这里记录下尽可能多的上下文信息，比如函数名、时间戳，然后决定是继续运行（如果危害不大）还是直接退出。很少会直接忽略它。
以下是
catch(...)的一些正确姿势：
-
记录日志并终止程序： 当你遇到一个完全未知的异常时，最安全的做法往往是记录下这个不可预知的错误，并尝试以一种受控的方式关闭程序，避免潜在的数据损坏或进一步的不可预测行为。
try { // ... 可能抛出各种异常的代码 } catch (const std::exception& e) { std::cerr << "已知标准异常: " << e.what() << std::endl; // 尝试恢复或优雅退出 } catch (...) { std::cerr << "捕获到未知异常，程序将终止。" << std::endl; // 记录日志，例如到文件 // std::abort(); // 强制终止 exit(EXIT_FAILURE); // 优雅退出 } 资源清理： 在某些情况下，即使你不知道异常类型，你也可能需要执行一些资源清理工作，例如关闭文件句柄、释放内存或解锁互斥量。
catch(...)
可以在这种情况下提供一个统一的清理点。-
重新抛出（Rethrow）未知异常： C++11及更高版本引入了
std::current_exception
和std::rethrow_exception
，这使得在catch(...)
块中捕获异常后，可以将其封装起来，稍后在其他地方重新抛出，从而将处理责任传递给更高级别的异常处理器。这对于构建通用的异常处理框架非常有用。#include
// for std::current_exception, std::rethrow_exception void lowLevelFunc() { throw "一个神秘的错误!"; // 抛出C风格字符串 } void midLevelFunc() { std::exception_ptr p; // 异常指针 try { lowLevelFunc(); } catch (...) { std::cerr << "中层函数捕获到未知异常，记录并重新抛出。" << std::endl; p = std::current_exception(); // 获取当前异常的指针 } if (p) { std::rethrow_exception(p); // 重新抛出捕获到的异常 } } int main() { try { midLevelFunc(); } catch (const char* msg) { std::cerr << "顶层函数捕获到字符串异常: " << msg << std::endl; } catch (...) { std::cerr << "顶层函数捕获到其他未知异常。" << std::endl; } return 0; } 这种方式允许你在中间层进行一些日志记录或局部清理，然后将异常“转发”给更了解如何处理它的上层代码。这比直接在
catch(...)
里做太多事情要好，因为它保持了异常的原始类型信息。
自定义异常类型在多异常捕获中的优势是什么？
我个人觉得，设计一套好的自定义异常体系，比单纯依赖
std::exception或内置类型要清晰得多。它让错误处理变得有章可循，也更容易扩展。自定义异常类型在多异常捕获中拥有显著的优势，主要体现在以下几个方面：
清晰的语义和意图： 标准库的异常（如
std::runtime_error
）虽然有用，但它们的名称通常比较通用。自定义异常允许你用业务领域的语言来描述错误，例如FileNotFoundException
、DatabaseConnectionError
、InvalidInputException
等。这使得代码更具可读性，一眼就能看出异常代表的含义，也更容易理解抛出异常的场景。-
携带更多上下文信息： 标准异常通常只包含一个字符串消息。自定义异常可以添加额外的成员变量，来携带更丰富的上下文信息，这对于调试和错误恢复至关重要。例如，
FileNotFoundException
可以包含文件名和路径，DatabaseConnectionError
可以包含数据库IP地址和端口号，InvalidInputException
可以包含哪个字段输入错误以及期望的格式。#include
#include #include class BaseApplicationException : public std::runtime_error { public: BaseApplicationException(const std::string& msg, int code = 0) : std::runtime_error(msg), errorCode(code) {} int getErrorCode() const { return errorCode; } private: int errorCode; }; class FileOperationException : public BaseApplicationException { public: FileOperationException(const std::string& msg, const std::string& filename) : BaseApplicationException(msg, 1001), fileName(filename) {} const std::string& getFileName() const { return fileName; } private: std::string fileName; }; class NetworkOperationException : public BaseApplicationException { public: NetworkOperationException(const std::string& msg, const std::string& host) : BaseApplicationException(msg, 2001), hostName(host) {} const std::string& getHostName() const { return hostName; } private: std::string hostName; }; void processData(bool fileError, bool netError) { if (fileError) { throw FileOperationException("无法打开配置文件", "config.txt"); } if (netError) { throw NetworkOperationException("连接到服务器失败", "api.example.com"); } std::cout << "数据处理成功。" << std::endl; } int main() { try { processData(true, false); // 模拟文件错误 // processData(false, true); // 模拟网络错误 } catch (const FileOperationException& e) { std::cerr << "捕获到文件操作异常: " << e.what() << ", 文件名: " << e.getFileName() << ", 错误码: " << e.getErrorCode() << std::endl; } catch (const NetworkOperationException& e) { std::cerr << "捕获到网络操作异常: " << e.what() << ", 主机: " << e.getHostName() << ", 错误码: " << e.getErrorCode() << std::endl; } catch (const BaseApplicationException& e) { std::cerr << "捕获到通用应用异常: " << e.what() << ", 错误码: " << e.getErrorCode() << std::endl; } catch (const std::exception& e) { std::cerr << "捕获到标准异常: " << e.what() << std::endl; } return 0; } 构建异常层次结构： 通过继承，你可以创建一套异常类体系。例如，所有的文件相关异常可以继承自
FileBaseException
，所有的网络相关异常继承自NetworkBaseException
，而这些又可以继承自一个通用的ApplicationException
。这种层次结构允许你用一个catch
块捕获一整类异常（通过捕获基类），也可以用更具体的catch
块来处理特定的子类异常。这极大地提高了错误处理的灵活性和可维护性。提高代码可维护性： 当系统变得复杂时，错误类型会越来越多。自定义异常和异常层次结构使得管理这些错误变得有序。当你需要添加新的错误类型时，只需创建新的异常类并将其集成到现有层次结构中，而无需修改大量的现有
catch
块。
总而言之，自定义异常是C++中实现健壮、可读、可维护错误处理机制的基石。它们让错误不仅仅是一个“发生了什么”的模糊消息，而是带有丰富上下文和明确语义的、可操作的事件。
