C++标准异常类体系结构

2026-04-02 14:30:30 1260阅读 0评论

C++标准异常类体系结构探析

在C++编程中，异常处理是一个重要的概念，它允许程序在遇到错误时优雅地处理这些错误，而不是简单地崩溃。C++标准库提供了一个强大的异常类体系结构，帮助开发者更好地管理程序中的异常情况。本文将深入探讨C++标准异常类体系结构，帮助你理解如何有效地使用异常处理机制。

异常处理的基本概念

在C++中，异常处理主要通过三个关键字实现：try、catch 和 throw。

throw：用于抛出异常。当程序检测到错误时，可以使用 throw 关键字抛出一个异常对象。
catch：用于捕获并处理异常。在 try 块之后，可以使用多个 catch 块来捕获不同类型的异常。
try：用于包围可能抛出异常的代码块。如果 try 块中的代码抛出了异常，控制权将立即转移到相应的 catch 块。

标准异常类体系结构

C++标准库定义了一系列的异常类，它们都继承自 std::exception 类。以下是标准异常类体系结构的主要组成部分：

1. `std::exception`

这是所有标准异常类的基类。它定义了一个虚函数 what()，返回一个描述异常的字符串。

#include <exception>

class std::exception {
public:
    virtual const char* what() const noexcept = 0;
};

2. `std::bad_alloc`

这个异常类表示内存分配失败。通常在调用 new 或 malloc 时抛出。

#include <stdexcept>

class std::bad_alloc : public std::exception {
public:
    virtual const char* what() const noexcept override;
};

3. `std::bad_cast`

这个异常类表示类型转换失败。通常在使用 dynamic_cast 进行运行时类型检查时抛出。

#include <typeinfo>

class std::bad_cast : public std::exception {
public:
    virtual const char* what() const noexcept override;
};

4. `std::bad_function_call`

这个异常类表示尝试调用一个空的 std::function 对象。

#include <functional>

class std::bad_function_call : public std::exception {
public:
    virtual const char* what() const noexcept override;
};

5. `std::logic_error`

这个异常类表示逻辑错误。通常在程序逻辑上存在问题时抛出。

#include <stdexcept>

class std::logic_error : public std::exception {
public:
    explicit logic_error(const std::string& what_arg);
    virtual const char* what() const noexcept override;
};

6. `std::runtime_error`

这个异常类表示运行时错误。通常在程序运行过程中出现问题时抛出。

#include <stdexcept>

class std::runtime_error : public std::exception {
public:
    explicit runtime_error(const std::string& what_arg);
    virtual const char* what() const noexcept override;
};

7. `std::invalid_argument`

这个异常类表示传递给函数的参数无效。

#include <stdexcept>

class std::invalid_argument : public std::logic_error {
public:
    explicit invalid_argument(const std::string& what_arg);
    virtual const char* what() const noexcept override;
};

8. `std::out_of_range`

这个异常类表示操作超出范围。

#include <stdexcept>

class std::out_of_range : public std::logic_error {
public:
    explicit out_of_range(const std::string& what_arg);
    virtual const char* what() const noexcept override;
};

9. `std::length_error`

这个异常类表示请求的操作导致长度超过最大值。

#include <stdexcept>

class std::length_error : public std::logic_error {
public:
    explicit length_error(const std::string& what_arg);
    virtual const char* what() const noexcept override;
};

10. `std::domain_error`

这个异常类表示数学运算的参数域错误。

#include <stdexcept>

class std::domain_error : public std::logic_error {
public:
    explicit domain_error(const std::string& what_arg);
    virtual const char* what() const noexcept override;
};

11. `std::overflow_error`

这个异常类表示数值溢出。

#include <stdexcept>

class std::overflow_error : public std::runtime_error {
public:
    explicit overflow_error(const std::string& what_arg);
    virtual const char* what() const noexcept override;
};

12. `std::underflow_error`

这个异常类表示数值下溢。

#include <stdexcept>

class std::underflow_error : public std::runtime_error {
public:
    explicit underflow_error(const std::string& what_arg);
    virtual const char* what() const noexcept override;
};

如何使用标准异常类

在实际开发中，你可以根据需要抛出和捕获标准异常类。以下是一个简单的示例：

#include <iostream>
#include <stdexcept>

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

int main() {
    try {
        divide(10, 0);
    } catch (const std::invalid_argument& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    return 0;
}

在这个示例中，我们定义了一个 divide 函数，当除数为零时抛出 std::invalid_argument 异常。在 main 函数中，我们使用 try-catch 块捕获并处理这个异常。

自定义异常类

除了使用标准异常类外，你还可以创建自己的异常类。自定义异常类应该继承自 std::exception 或其派生类，并重载 what() 方法。

#include <iostream>
#include <exception>

class MyException : public std::exception {
public:
    const char* what() const noexcept override {
        return "This is my custom exception.";
    }
};

int main() {
    try {
        throw MyException();
    } catch (const MyException& e) {
        std::cerr << "Caught an exception: " << e.what() << std::endl;
    }
    return 0;
}

在这个示例中，我们定义了一个自定义异常类 MyException，并在 main 函数中捕获并处理这个异常。