以下程序的定义行为是什么(如果有)？

#include <iostream>
#include <exception>
#include <cstdlib>

void i_throw()
{
    std::cout << "i_throw()" << std::endl;
    // std::terminate() is noexcept so if the terminate handler throws...
    // then the terminate handler is called...
    // std::terminate is [[noreturn]] so don't return
    try
    {
        throw 7;
    }
    catch(...)
    {
        std::cout << "caught exception, re-throw()-ing" << std::endl;
        throw;
    }
    std::cout << "got here!" << std::endl;
    std::abort();
}

int main()
{
    std::set_terminate(i_throw);
    throw;
    std::terminate();
}

使用 gcc 和 clang 我得到以下输出:

i_throw()
caught exception, re-throw()-ing
Aborted (core dumped)

在前几条评论后编辑的示例。

(我不知道为什么我有 throw; 和 std::terminate();。我不想改变这个例子，所以只是假装这两个中只有一个在那里。)

最佳答案

上述问题可以归结为理解以下两个代码片段的行为。

示例 1: 没有事件异常的抛出

int main()
{
    try{
        throw;
    }catch(...){
        std::cout<<"caught"<<endl;  //we never reach here
    }
    return 0;
}

如果你运行上面的代码，它会崩溃，如下所示

terminate called without an active exception
Aborted (core dumped)

示例 2: 抛出事件异常

int main()
{
    try{
        throw 7;
    }catch(...){
        std::cout<<"caught"<<endl;  //will be caught
    }
    return 0;
}

运行它会给出可预测的输出

caught

如果生成代码的程序集 (g++ -S option)。您会注意到以下 cxx_abi 调用 throw 与 throw 7

throw;转换为 call __cxa_rethrow

和

throw 7;转换为 call __cxa_throw

这是 __cxa_throw 的代码

extern "C" void
__cxxabiv1::__cxa_throw (void *obj, std::type_info *tinfo,
             void (_GLIBCXX_CDTOR_CALLABI *dest) (void *))
{
  PROBE2 (throw, obj, tinfo);

  __cxa_eh_globals *globals = __cxa_get_globals ();
  globals->uncaughtExceptions += 1;

  // code removed for brevity 
  //.......
  // Below code throws an exception to be caught by caller

  #ifdef _GLIBCXX_SJLJ_EXCEPTIONS
    _Unwind_SjLj_RaiseException (&header->exc.unwindHeader);
  #else
    _Unwind_RaiseException (&header->exc.unwindHeader);
  #endif

  // Some sort of unwinding error.  Note that terminate is a handler.
  __cxa_begin_catch (&header->exc.unwindHeader);
  std::terminate ();
}

因此，在 OP 代码中 throw 7;会被对应的catch(...)抓到并将被 throw; 重新抛出

这是 __cxa__rethrow 的代码

extern "C" void
__cxxabiv1::__cxa_rethrow ()
{
  __cxa_eh_globals *globals = __cxa_get_globals ();
  __cxa_exception *header = globals->caughtExceptions; // We are not re

  globals->uncaughtExceptions += 1;

  // Watch for luser rethrowing with no active exception.
  if (header)
    {
      // Code removed for brevity
      // .....
      // Below code rethrows the exception
      #ifdef _GLIBCXX_SJLJ_EXCEPTIONS
      _Unwind_SjLj_Resume_or_Rethrow (&header->unwindHeader);
      #else
      #if defined(_LIBUNWIND_STD_ABI)
      _Unwind_RaiseException (&header->unwindHeader);
      #else
      _Unwind_Resume_or_Rethrow (&header->unwindHeader);
      #endif
      #endif
    }
  std::terminate ();
}

在这两种情况下，我们都可以看到 std::terminate()尚未从 __cxx_* 调用.在被上面的 abi 抛出后，我们在代码中的以下位置。

引用cxx_abi用于终止代码。

void
__cxxabiv1::__terminate (std::terminate_handler handler) throw ()
{
  __try 
    {
      handler ();      // Our handler has thrown an int exception
      std::abort ();
    } 
  __catch(...)  // Exception is caught here and process is aborted.
    { std::abort (); } 
}

void
std::terminate () throw()
{
  __terminate (get_terminate ());
}

总结

根据我的理解，处理程序重新抛出异常会导致在 __cxxabiv1::__terminate 中捕获重新抛出的异常。 .它在哪里调用 abort() .显然，std::terminate() [来自 __cxa_rethrow] 方法没有出现在图片中，这就是为什么控件从未达到 std::cout << "got here!" << std::endl; 的原因

无限递归

如果我们将 terminate_handler 更改为以下内容会发生什么:

void i_throw()
{
    std::cout << "i_throw()" << std::endl;
    throw;
    std::cout << "got here!" << std::endl;
    std::abort();
}

要理解这一点，我们可以查看 __cxa_rethrow()正如刚才提到的。

因为没有抛出事件异常，__cxa_rethrow()最终会调用std::terminate() ，从而导致无限递归。

关于c++ - 终止处理程序可以抛出异常吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/28757161/