C++如何捕获多个异常类型-C++-PHP中文网

C++通过多个catch块捕获不同异常类型，按从具体到通用的顺序匹配，确保精确处理；catch(...)用于捕获未知异常，适合作为最后防线进行日志记录或资源清理，避免程序崩溃。

c++如何捕获多个异常类型

C++捕获多个异常类型主要通过使用多个

catch

登录后复制

块，每个块处理一种特定的异常类型，或者使用一个通用的

catch(...)

登录后复制

块来捕获所有未知或未明确处理的异常。理解它们的优先级和适用场景，是写出健壮C++代码的关键。

解决方案

在C++中处理异常，特别是当你的代码可能抛出多种不同类型的错误时，我们需要一种机制来区分和响应这些错误。最直接也是最常用的方法，就是堆叠

catch

登录后复制

块。

你可以为每一种你预期可能出现的异常类型编写一个

catch

登录后复制

块。例如，你可能有一个文件操作失败的异常，一个网络连接超时的异常，或者一个内存分配不足的异常。代码看起来会是这样：

#include <iostream>
#include <stdexcept> // 包含标准异常类，如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 <iostream>
#include <stdexcept>

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(...)

登录后复制

通常不用于恢复程序状态，而是作为最后的防线。我通常会在这里记录下尽可能多的上下文信息，比如函数名、时间戳，然后决定是继续运行（如果危害不大）还是直接退出。很少会直接忽略它。

千面视频动捕

千面视频动捕是一个AI视频动捕解决方案，专注于将视频中的人体关节二维信息转化为三维模型动作。

查看详情

以下是

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 <exception> // 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 <iostream>
#include <stdexcept>
#include <string>

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
```
登录后复制
块。