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(...)
的正确姿势）？
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_exceptionvoid 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++中实现健壮、可读、可维护错误处理机制的基石。它们让错误不仅仅是一个“发生了什么”的模糊消息，而是带有丰富上下文和明确语义的、可操作的事件。
以上就是C++如何捕获多个异常类型的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1475125.html
微信扫一扫 
支付宝扫一扫 
