C++11 异常设计。习语和最佳实践改变了吗？

Question

我想知道，自 C++11 以来，添加了在线程之间传递异常并添加了嵌套异常，通常情况下是否会更改用于异常捕获的惯用语。

现在我们有了：

1. std::rethrow_if_nested
2. std::rethrow_with_nested
3. std::rethrow_exception
4. std::current_exception

嵌套异常应该用于不丢失异常上下文。

所以现在你可以这样做：

void open_file(std::string const & file_name) {
   try {
      std::ifstream file;
      file.exceptions(ios::failbit | ios::badbit);
      file.open(file_name);
   }
   catch (...) {
      std::rethrow_with_nested(std::logic_error("File " + file_name + 
      " could not be open"));
   }
}

如果我没记错的话，你可以像这样得到回溯：

void print_backtrace(std::exception const & e, int depth = 0) {
   std::cerr << std::string(depth, ' ') << e.what() << std::endl;
   try {
      std::rethrow_if_nested(e);
   }
   catch (std::exception const & ex) {
      print_backtrace(ex, ++depth);
   }
}

因此，如果您将print_backtrace 与open_file 一起使用，它应该在输出中为您提供std::logic_error + ios_base::failure。

我的问题是：

1. 考虑到我想在不丢失上下文的情况下捕获所有异常，这个习惯用法是在 c++11 中处理异常的“正确”方式吗？
2. print_backtrace 函数中是否有办法捕获异常，catch (...) 可以完全捕获所有异常？
3. 我不知道为什么需要std::rethrow_exception，也不知道什么时候需要。

Answer 1

1。我不知道我会称之为成语。如果你所说的“正确”是指类似于std::vector 是默认使用的“正确”容器，我认为实际上并没有一种特定的“正确”处理错误的方式。这是一种正确的方法，因为它是明确定义的行为。

2。首先，您必须在不限于某些例外的上下文中调用 print_backtrace()，这意味着您必须在 catch(...) 块中调用它：

    try {
      run();
    } catch(...) {
      print_backtrace();
    }

但是你没有已知类型的异常可以传递给函数。相反，您必须编写函数以不同方式访问异常；通过抛出该异常并在内部捕获它（因为这是您可以将已知类型的变量绑定到任意异常的唯一机制）。

void print_backtrace(int depth = 0) {
  try {
    throw;
  }

  // this block shows how to handle exceptions of some known type
  // You can have your own types instead of std::exception
  catch (const std::exception & e) {
    std::cerr << std::string(depth, ' ') << e.what() << std::endl;
    try {
      std::rethrow_if_nested(e);
    }
    catch (...) {
      print_backtrace(++depth);
    }
  }

  // Not all nesting exceptions will be of a known type, but if they use the
  // mixin type std::nested_exception, then we can at least handle them enough to
  // get the nested exception:

  catch (const std::nested_exception & ne) {
    std::cerr << std::string(depth, ' ') << "Unknown nesting exception\n";

    try {
      ne.rethrow_nested();
    }
    catch (...) {
      print_backtrace(++depth);
    }
  }

  // Exception nesting works through inheritance, which means that if you
  // can't inherit from the type, then you can't 'mixin' std::nesting exception.
  // If you try something like std::throw_with_nested( int{10} ); Then you'll
  // hit this catch block when printing the backtrace.

  catch (...) {
    std::cerr << std::string(depth, ' ') << "Unknown exception\n";
  }
}

3。 std::rethrow_exception 与std::exception_ptr 一起使用，这是一种可用于传输任意异常的类型。获得该异常的唯一方法是使用正常的异常处理机制来处理catch 异常，这意味着您必须能够抛出该异常。这就是rethrow_exception 所做的。这可用于将任意异常从一个线程传输到另一个线程（如 std::future 所做的那样），或将任意异常作为成员保存（如 std::nested_exception 所做的那样），或将任意异常作为参数传递给将尝试打印一些异常描述的函数。

void print_backtrace(std::exception_ptr e) {
  try {
    std::rethrow_exception(e);
  }

  catch (const std::exception & e) {
    // ...