C++

参考

<exception>

nested_exception

类
<exception>

std::nested_exception

class nested_exception;
嵌套异常类
一种异常类的组件，它可以捕获当前处理的异常作为嵌套异常。

一个类，该类同时派生自此类和另一个异常类，它可以保存这两个异常的属性：当前处理的异常（作为其嵌套异常）和另一个异常（其外部异常）。

通常通过调用带有一个外部异常对象作为参数的 throw_with_nested 来构造具有嵌套异常的对象。返回的对象具有与外部异常相同的属性和成员，但携带与嵌套异常相关的附加信息，并包含两个成员函数来访问此嵌套异常：nested_ptr 和 rethrow_nested。

其声明如下：
1
2
3
4
5
6
7
8
9
10
 
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;
}

成员函数

（构造函数）
构造 nested_exception (public member function)
rethrow_nested
重新抛出嵌套异常 (public member function)
nested_ptr
获取嵌套异常的 exception_ptr (函数)

拷贝赋值和虚析构函数是显式默认的。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
// nested_exception example
#include <iostream>       // std::cerr
#include <exception>      // std::exception, std::throw_with_nested, std::rethrow_if_nested
#include <stdexcept>      // std::logic_error

// recursively print exception whats:
void print_what (const std::exception& e) {
  std::cerr << e.what() << '\n';
  try {
    std::rethrow_if_nested(e);
  } catch (const std::exception& nested) {
    std::cerr << "nested: ";
    print_what(nested);
  }
}

// throws an exception nested in another:
void throw_nested() {
  try {
    throw std::logic_error ("first");
  } catch (const std::exception& e) {
    std::throw_with_nested(std::logic_error("second"));
  }
}

int main () {
  try {
    throw_nested();
  } catch (std::exception& e) {
    print_what(e);
  }

  return 0;
}

输出

second
nested: first