C++如何使用标准异常类std::exception-C++-PHP中文网

C++如何使用标准异常类std::exception

P粉602998670

发布： 2025-09-18 16:28:02

原创

770人浏览过

使用std::exception可构建健壮代码，其继承体系提供标准错误处理机制；应合理使用标准异常类如std::invalid_argument，并在需传递额外信息时自定义异常类；避免使用已废弃的异常规范，改用noexcept；通过RAII等技术保证异常安全，防止资源泄漏。

c++如何使用标准异常类std::exception

C++中使用

std::exception

登录后复制

，本质上是为了构建更健壮、更易于维护的代码。它提供了一种标准的、结构化的方式来处理程序运行期间可能出现的各种错误。不必每次都手动构建错误处理机制，而是可以依赖于这个预定义的类及其派生类。

使用

std::exception

登录后复制

，核心在于理解其继承体系，并在适当的时候抛出和捕获异常。

解决方案：

C++标准库提供了一系列从

std::exception

登录后复制

派生的异常类，用于表示不同类型的错误。例如：

立即学习“C++免费学习笔记（深入）”；

```
std::bad_alloc
```
登录后复制
: 当
```
new
```
登录后复制
操作符无法分配内存时抛出。
```
std::bad_cast
```
登录后复制
: 当使用
```
dynamic_cast
```
登录后复制
进行类型转换失败时抛出。
```
std::invalid_argument
```
登录后复制
: 当函数接收到无效参数时抛出。
```
std::out_of_range
```
登录后复制
: 当试图访问超出范围的容器元素时抛出。
```
std::runtime_error
```
登录后复制
: 用于报告运行时发生的错误。
```
std::logic_error
```
登录后复制
: 用于报告程序逻辑上的错误。

以下是一个使用

std::exception

登录后复制

的简单例子：

#include <iostream>
#include <stdexcept>

int divide(int a, int b) {
    if (b == 0) {
        throw std::invalid_argument("Division by zero is not allowed.");
    }
    return a / b;
}

int main() {
    try {
        int result = divide(10, 0);
        std::cout << "Result: " << result << std::endl;
    } catch (const std::invalid_argument& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    } catch (const std::exception& e) {
        std::cerr << "An unexpected error occurred: " << e.what() << std::endl;
        return 1;
    } catch (...) {
        std::cerr << "Unknown exception caught!" << std::endl;
        return 1;
    }

    return 0;
}

登录后复制

在这个例子中，

divide

登录后复制

函数在除数为零时抛出一个

std::invalid_argument

登录后复制

异常。

main

登录后复制

函数中的

try-catch

登录后复制

块捕获这个异常，并打印错误信息。注意，最后的

catch(...)

登录后复制

可以捕获所有未被前面

catch

登录后复制

块处理的异常，但通常不建议过度使用，因为它会隐藏具体的错误类型。

何时应该自定义异常类？

并非所有错误都需要使用标准异常类。在某些情况下，自定义异常类可能更合适。例如，当需要传递额外的错误信息，或者需要区分特定于应用程序的错误类型时，自定义异常类就显得很有必要。

自定义异常类通常从

std::exception

登录后复制

或其派生类继承，并添加自己的成员变量和方法来存储和访问错误信息。

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

class MyCustomException : public std::runtime_error {
public:
    MyCustomException(const std::string& message, int errorCode)
        : std::runtime_error(message), errorCode_(errorCode) {}

    int getErrorCode() const {
        return errorCode_;
    }

private:
    int errorCode_;
};

int processData(int data) {
    if (data < 0) {
        throw MyCustomException("Data is invalid.", 1001);
    }
    return data * 2;
}

int main() {
    try {
        int result = processData(-5);
        std::cout << "Result: " << result << std::endl;
    } catch (const MyCustomException& e) {
        std::cerr << "Custom Exception caught: " << e.what()
                  << ", Error Code: " << e.getErrorCode() << std::endl;
        return 1;
    } catch (const std::exception& e) {
        std::cerr << "Standard Exception caught: " << e.what() << std::endl;
        return 1;
    }

    return 0;
}

登录后复制

在这个例子中，

MyCustomException

登录后复制

继承自

std::runtime_error

登录后复制

，并添加了一个

errorCode_

登录后复制

成员变量来存储自定义的错误代码。

异常规范（Exception Specifications）是否应该使用？

在C++11之前，可以使用异常规范来声明函数可能抛出的异常类型。例如：

标小兔AI写标书

一款专业的标书AI代写平台，提供专业AI标书代写服务，安全、稳定、速度快，可满足各类招投标需求，标小兔，写标书，快如兔。

查看详情

void myFunction() throw (std::runtime_error, std::bad_alloc);

登录后复制

这表明

myFunction

登录后复制

可能会抛出

std::runtime_error

登录后复制

或

std::bad_alloc

登录后复制

异常。然而，异常规范在C++11中被废弃，并在C++17中被移除。现在，只剩下

noexcept

登录后复制

规范，用于声明函数不会抛出任何异常。

使用

noexcept

登录后复制

可以帮助编译器进行优化，并提供更强的异常安全保证。例如：

void myFunction() noexcept;

登录后复制

这表明

myFunction

登录后复制

不会抛出任何异常。如果

myFunction

登录后复制

内部抛出了异常，程序会立即终止（调用

std::terminate

登录后复制

）。

因此，不建议使用C++11之前的异常规范。应该使用

noexcept

登录后复制

来声明不抛出异常的函数。

如何保证异常安全？

异常安全是指在异常抛出时，程序的状态仍然保持一致。这通常需要仔细设计代码，以确保资源得到正确释放，数据结构保持有效。

以下是一些保证异常安全的常用技巧：

RAII (Resource Acquisition Is Initialization): 使用RAII技术来管理资源，例如使用智能指针来自动释放内存。
Copy-and-Swap: 在修改对象状态之前，先创建一个副本，然后在副本上进行修改。如果修改过程中发生异常，原始对象的状态不会受到影响。修改完成后，将副本与原始对象进行交换。
Strong Exception Safety: 保证操作要么完全成功，要么完全不产生副作用。如果操作失败，程序的状态应该恢复到操作之前的状态。
Basic Exception Safety: 保证操作不会导致资源泄漏，并且对象的状态仍然有效。
No-Throw Guarantee: 保证操作不会抛出任何异常。

例如，使用RAII技术来管理互斥锁：

#include <iostream>
#include <mutex>
#include <stdexcept>

class LockGuard {
public:
    LockGuard(std::mutex& mutex) : mutex_(mutex) {
        mutex_.lock();
    }

    ~LockGuard() {
        mutex_.unlock();
    }

private:
    std::mutex& mutex_;
};

void processData(int data, std::mutex& mutex) {
    LockGuard lock(mutex); // Acquire lock

    if (data < 0) {
        throw std::invalid_argument("Data is invalid.");
    }

    // Process data
    std::cout << "Processing data: " << data << std::endl;
}

int main() {
    std::mutex mutex;

    try {
        processData(-5, mutex);
    } catch (const std::exception& e) {
        std::cerr << "Exception caught: " << e.what() << std::endl;
        return 1;
    }

    return 0;
}

登录后复制

在这个例子中，