当前头文件原本是语言支持库(Language support library)中的部分内容,本手册将其合并到了诊断库(Diagnostics library)中。

语言支持库(参考手册) ​语言支持库(标准)

诊断库(参考手册) ​诊断库(标准)

  • exception 由标准库组件(Standard library component)抛出的异常的基类
    nested_exception C++11 这是一个混合类型(Mixin type),用于捕获及存储当前异常
    bad_exception 动态异常规范被违反时将会抛出的异常
  • unexpected 已弃用 动态异常规范被违反时将会调用的函数
    unexpected_handler 已弃用 unexpected 调用的函数的类型
    terminate_handler terminate 调用的函数的类型
    exception_ptr C++11 用于操作异常对象的共享指针类型
  • 捕获及存储异常对象

    uncaught_exception 检测异常处理是否正在进行
    make_exception_ptr C++11 创建一个指向异常对象拷贝的 exception_ptr 对象
    current_exception C++11 捕获当前异常
    rethrow_exception C++11 再次抛出异常
    throw_with_nested C++11 嵌套当前异常及参数中保存的异常且抛出
    rethrow_if_nested C++11 如果异常嵌套,则再次抛出异常

    异常处理时的失败处理

    terminate 异常处理失败时将会调用的函数
    get_terminate C++11 获得当前中止处理例程(Terminate handler)
    set_terminate 设置当前中止处理例程

    违反异常规范的处理

    get_unexpected 已弃用 获得当前意外处理例程(Unexpected handler)
    set_unexpected 已弃用 设置当前意外处理例程
  • namespace std {
        class exception;
        class bad_exception;
        class nested_exception;
     
        typedef void (*unexpected_handler)();
        unexpected_handler get_unexpected() noexcept;
        unexpected_handler set_unexpected(unexpected_handler f) noexcept;
        [[noreturn]] void unexpected();
     
        typedef void (*terminate_handler)();
        terminate_handler get_terminate() noexcept;
        terminate_handler set_terminate(terminate_handler f) noexcept;
        [[noreturn]] void terminate() noexcept;
     
        bool uncaught_exception() noexcept;
     
        typedef /*unspecified*/ 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;
     
        [[noreturn]] template <class T> void throw_with_nested(T&& t);
        template <class E> void rethrow_if_nested(const E& e);
    }
  • class exception {
    public:
        exception() noexcept;
        exception(const exception&) noexcept;
        exception& operator=(const exception&) noexcept;
        virtual ~exception();
        virtual const char* what() const noexcept;
    };
  • class bad_exception : public exception {
    public:
        bad_exception() noexcept;
        bad_exception(const bad_exception&) noexcept;
        bad_exception& operator=(const bad_exception&) noexcept;
        virtual const char* what() const noexcept;
    };
  • 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;
     
        // access functions
        [[noreturn]] void rethrow_nested() const;
        exception_ptr nested_ptr() const noexcept;
    };