std::uncaught_exception

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

Utilities library

Type support (basic types, RTTI, type traits)

Dynamic memory management

Error handling

Program utilities

Variadic functions

Date and time

Function objects

initializer_list (C++11)

bitset

hash (C++11)

Relational operators

rel_ops::operator!= rel_ops::operator> rel_ops::operator<= rel_ops::operator>=

Pairs and tuples

pair

tuple (C++11)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

Swap, forward and move

swap

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

declval (C++11)

 

Error handling

Exception handling

exception

uncaught_exception

exception_ptr (C++11)

make_exception_ptr (C++11)

current_exception (C++11)

rethrow_exception (C++11)

nested_exception (C++11)

throw_with_nested (C++11)

rethrow_if_nested (C++11)

Exception handling failures

terminate

terminate_handler

get_terminate (C++11)

set_terminate

unexpected (deprecated)

bad_exception

unexpected_handler (deprecated)

get_unexpected (C++11)(deprecated)

set_unexpected (deprecated)

Exception categories

logic_error

invalid_argument

domain_error

length_error

out_of_range

runtime_error

range_error

overflow_error

underflow_error

Error codes

Error codes

errno

Assertions

assert

system_error facility

error_category (C++11)

generic_category (C++11)

system_category (C++11)

error_condition (C++11)

errc (C++11)

error_code (C++11)

system_error (C++11)

 

Defined in header <exception>
bool uncaught_exception();

Detects if the current thread has a live exception object, that is, an exception has been thrown and not yet entered a matching catch clause, std::terminate or std::unexpected. In other words, std::uncaught_exception detects if stack unwinding is currently in progress.

Sometimes it's safe to throw an exception even while std::uncaught_exception() == true. For example, if stack unwinding causes a stack-allocated object to be destructed, the destructor for that object could run code that throws an exception as long as the exception is caught by some catch block before escaping the destructor.

Parameters

(none)

Return value

true if stack unwinding is currently in progress in this thread.

Exceptions

noexcept specification:  

noexcept

  (since C++11)

Example

run this code

#include <iostream>
#include <exception>
#include <stdexcept>
 
struct Foo {
    ~Foo() {
        if (std::uncaught_exception()) {
            std::cout << "~Foo() called during stack unwinding\n";
        } else {
            std::cout << "~Foo() called normally\n";
        }
    }
};
int main()
{
    Foo f;
    try {
        Foo f;
        std::cout << "Exception thrown\n";
        throw std::runtime_error("test exception");
    } catch (const std::exception& e) {
        std::cout << "Exception caught: " << e.what() << '\n';
    }
}

Output:

Exception thrown
~Foo() called during stack unwinding
Exception caught: test exception
~Foo() called normally

See also

terminate	function called when exception handling fails (function)
exception_ptr (C++11)	shared pointer type for handling exception objects (typedef)

External links

GOTW issue 47: Uncaught Exceptions