Page History

...

The C++ Standard defines several ways in which std::terminate() may be called implicitly by an implementation [ISO/IEC 14882-2014]:

1. When the exception handling mechanism, after completing the initialization of the exception object but before activation of a handler for the exception, calls a function that exits via an exception. ([except.throw], paragraph 7)
   
   • See ERR60-CPP. Exception objects must be nothrow copy constructible
2. When a throw-expression with no operand attempts to rethrow an exception and no exception is being handled. ([except.throw], paragraph 9)
3. When the exception handling mechanism cannot find a handler for a thrown exception. ([except.handle], paragraph 9)
   • See ERR51-CPP. Handle all exceptions for more information.
4. When the search for a handler encounters the outermost block of a function with a noexcept-specification that does not allow the exception. ([except.spec], paragraph 9)
   • See ERR55-CPP. Honor exception specifications for more information.
5. When the destruction of an object during stack unwinding terminates by throwing an exception. ([except.ctor], paragraph 3)
   • See DCL57-CPP. Do not let exceptions escape from destructors or deallocation functions for more information.
6. When initialization of a nonlocal variable with static or thread storage duration exits via an exception. ([basic.start.init], paragraph 6)
   
   • See ERR58-CPP. Constructors of objects with static or thread storage duration must not throw exceptionsHandle all exceptions thrown before main() begins executing for more information.
7. When destruction of an object with static or thread storage duration exits via an exception. ([basic.start.term], paragraph 1)
   • See DCL57-CPP. Do not let exceptions escape from destructors or deallocation functions
8. When execution of a function registered with std::atexit() or std::at_quick_exit() exits via an exception. ([support.start.term], paragraphs 8 and 12)
9. When the implementation’s default unexpected exception handler is called. ([except.unexpected], paragraph 2) Note that std::unexpected() is currently deprecated.
10. When std::unexpected() throws an exception that is not allowed by the previously violated dynamic-exception-specification, and std::bad_exception() is not included in that dynamic-exception-specification. ([except.unexpected], paragraph 3)
    
11. When the function std::nested_exception::rethrow_nested() is called for an object that has captured no exception. ([except.nested], paragraph 4)
    
12. When execution of the initial function of a thread exits via an exception. ([thread.thread.constr], paragraph 5)
    • See ERR51-CPP. Handle all exceptions for more information.
13. When the destructor is invoked on an object of type std::thread that refers to a joinable thread. ([thread.thread.destr], paragraph 1)
14. When the copy assignment operator is invoked on an object of type std::thread that refers to a joinable thread. ([thread.thread.assign], paragraph 1)
    
15. When calling condition_variable::wait(), condition_variable::wait_until(), or condition_variable::wait_for() results in a failure to meet the postcondition: lock.owns_lock() == true or lock.mutex() is not locked by the calling thread. ([thread.condition.condvar], paragraphs 11, 16, 21, 28, 33, and 40)
16. When calling condition_variable_any::wait(), condition_variable_any::wait_until(), or condition_variable_any::wait_for() results in a failure to meet the postcondition: lock is not locked by the calling thread. ([thread.condition.condvarany], paragraphs 11, 16, and 22)

In many circumstances, the call stack will not be unwound in response to an implicit call to std::terminate(), and in a few cases, it is implementation-defined whether or not stack unwinding will occur. The C++ Standard, [except.terminate], paragraph 2 [ISO/IEC 14882-2014], states, in part:

In the situation where no matching handler is found, it is implementation-defined whether or not the stack is unwound before std::terminate() is called. In the situation where the search for a handler encounters the outermost block of a function with a noexcept-specification that does not allow the exception, it is implementation-defined whether the stack is unwound, unwound partially, or not unwound at all before std::terminate() is called. In all other situations, the stack shall not be unwound before std::terminate() is called.

...

...

...