# 标准库头文件 <exception>

< cpp‎ | header

此头文件是错误处理库的一部分。

### 类
exception | 标准库组件抛出的各种异常的基类 (类)
nested_exception (C++11) | 用于捕获并存储当前异常的混入类型 (类)
bad_exception | 当 std::current_exception 无法复制异常对象时抛出的异常 (类)
unexpected_handler (C++17 中移除) | std::unexpected 所调用的函数类型 (typedef)
terminate_handler | std::terminate 所调用的函数类型 (typedef)
exception_ptr (C++11) | 用于处理异常对象的共享指针类型 (typedef)
### 函数
unexpected (C++17 中移除) | 违背动态异常说明时调用的函数 (函数)
uncaught_exception uncaught_exceptions (C++20 中移除)(C++17) | 检查当前是否正在进行异常处理 (函数)
make_exception_ptr (C++11) | 从异常对象创建一个std::exception_ptr (函数模板)
current_exception (C++11) | 捕获当前异常到 std::exception_ptr 之中 (函数)
rethrow_exception (C++11) | 从一个 std::exception_ptr 抛出异常 (函数)
throw_with_nested (C++11) | 抛出实参，带上混入的 std::nested_exception (函数模板)
rethrow_if_nested (C++11) | 抛出 std::nested_exception 中的异常 (函数模板)
terminate | 异常处理失败时调用的函数 (函数)
get_terminate (C++11) | 获得当前的 terminate_handler (函数)
set_terminate | 更改将被 std::terminate 调用的函数 (函数)
get_unexpected (C++11)(C++17 中移除) | 获得当前的 unexpected_handler (函数)
set_unexpected (C++17 中移除) | 更改要被 std::unexpected 调用的函数 (函数)

### 概要

    namespace std {
      class exception;
      class bad_exception;
      class nested_exception;

      using terminate_handler = void (*)();
      terminate_handler get_terminate() noexcept;
      terminate_handler set_terminate(terminate_handler f) noexcept;
      [[noreturn]] void terminate() noexcept;

      int uncaught_exceptions() noexcept;

      using exception_ptr = /* 未指明 */;

      exception_ptr current_exception() noexcept;
      [[noreturn]] void rethrow_exception(exception_ptr p);
      template<class E> exception_ptr make_exception_ptr(E e) noexcept;

      template<class T> [[noreturn]] void throw_with_nested(T&& t);
      template<class E> void rethrow_if_nested(const E& e);
    }

#### 类 std::exception

    namespace std {
      class exception {
      public:
        exception() noexcept;
        exception(const exception&) noexcept;
        exception& operator=(const exception&) noexcept;
        virtual ~exception();
        virtual const char* what() const noexcept;
      };
    }

#### 类 std::bad_exception

    namespace std {
      class bad_exception : public exception {
      public:
        // 特殊成员函数的规定见 [exception]
        const char* what() const noexcept override;
      };
    }

#### 类 std::nested_exception

    namespace std {
      class nested_exception {
      public:
        nested_exception() noexcept;
        nested_exception(const nested_exception&) noexcept = default;
        nested_exception& operator=(const nested_exception&) noexcept = default;
        virtual ~nested_exception() = default;

        // 访问函数
        [[noreturn]] void rethrow_nested() const;
        exception_ptr nested_ptr() const noexcept;
      };

      template<class T> [[noreturn]] void throw_with_nested(T&& t);
      template<class E> void rethrow_if_nested(const E& e);
    }

### 参阅

- 错误处理