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

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

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 
#include 

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 
#include 
#include 

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之前，可以使用异常规范来声明函数可能抛出的异常类型。例如：

Python v2.4 中文手册 chm

Python v2.4版chm格式的中文手册，内容丰富全面，不但是一本手册，你完全可以把她作为一本Python的入门教程，教你如何使用Python解释器、流程控制、数据结构、模板、输入和输出、错误和异常、类和标准库详解等方面的知识技巧。同时后附的手册可以方便你的查询。

下载

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

这表明

myFunction

std::runtime_error

std::bad_alloc

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 
#include 
#include 

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;
}

在这个例子中，

LockGuard

LockGuard

LockGuard

总而言之，

std::exception