Diagnostics library
Exception handling
The header <exception> provides several classes and functions related to exception handling in C++ programs.
|
Defined in header
<exception>
|
|
|
base class for exceptions thrown by the standard library components
(class) |
|
Capture and storage of exception objects |
|
|
(
removed in C++20*
)
(C++17)
|
checks if exception handling is currently in progress
(function) |
|
(C++11)
|
shared pointer type for handling exception objects
(typedef) |
|
(C++11)
|
creates an
std::exception_ptr
from an exception object
(function template) |
|
(C++11)
|
captures the current exception in a
std::exception_ptr
(function) |
|
(C++11)
|
throws the exception from an
std::exception_ptr
(function) |
|
(C++11)
|
a mixin type to capture and store current exceptions
(class) |
|
(C++11)
|
throws its argument with
std::nested_exception
mixed in
(function template) |
|
(C++11)
|
throws the exception from a
std::nested_exception
(function template) |
Handling of failures in exception handling |
|
|
Defined in header
<exception>
|
|
|
function called when exception handling fails
(function) |
|
|
the type of the function called by
std::terminate
(typedef) |
|
|
(C++11)
|
obtains the current terminate_handler
(function) |
|
changes the function to be called by
std::terminate
(function) |
|
|
exception thrown when
std::current_exception
fails to copy the exception object
(class) |
|
Handling of exception specification violations (removed in C++17) |
|
|
(deprecated in C++11)
(removed in C++17)
|
function called when dynamic exception specification is violated
(function) |
|
(deprecated in C++11)
(removed in C++17)
|
the type of the function called by
std::unexpected
(typedef) |
|
(deprecated in C++11)
(removed in C++17)
|
obtains the current
unexpected_handler
(function) |
|
(deprecated in C++11)
(removed in C++17)
|
changes the function to be called by
std::unexpected
(function) |
Exception categories
Several convenience classes are predefined in the header
<stdexcept>
to report particular error conditions. These classes can be divided into two categories:
logic
errors and
runtime
errors. Logic errors are a consequence of faulty logic within the program and may be preventable. Runtime errors are due to events beyond the scope of the program and cannot easily be predicted.
|
Defined in header
<stdexcept>
|
|
|
exception class to indicate violations of logical preconditions or class invariants
(class) |
|
|
exception class to report invalid arguments
(class) |
|
|
exception class to report domain errors
(class) |
|
|
exception class to report attempts to exceed maximum allowed size
(class) |
|
|
exception class to report arguments outside of expected range
(class) |
|
|
exception class to indicate conditions only detectable at run time
(class) |
|
|
exception class to report range errors in internal computations
(class) |
|
|
exception class to report arithmetic overflows
(class) |
|
|
exception class to report arithmetic underflows
(class) |
|
|
(TM TS)
|
exception class to cancel atomic transactions
(class template) |
Error numbers
|
Defined in header
<cerrno>
|
|
|
macro which expands to POSIX-compatible thread-local error number variable
(macro variable) |
|
|
macros for standard POSIX-compatible error conditions
(macro constant) |
|
System error
The header
<system_error>
defines types and functions used to report error conditions originating from the operating system, streams I/O,
std::future
, or other low-level APIs.
|
Defined in header
<system_error>
|
|
|
(C++11)
|
base class for error categories
(class) |
|
(C++11)
|
identifies the generic error category
(function) |
|
(C++11)
|
identifies the operating system error category
(function) |
|
(C++11)
|
holds a portable error code
(class) |
|
(C++11)
|
the
std::error_condition
enumeration listing all standard
<cerrno>
macro constants
(class) |
|
(C++11)
|
holds a platform-dependent error code
(class) |
|
(C++11)
|
exception class used to report conditions that have an error_code
(class) |
Assertions
Assertions help to implement checking of preconditions in programs.
|
Defined in header
<cassert>
|
|
|
aborts the program if the user-specified condition is not
true
. May be disabled for release builds.
(function macro) |
|
Stacktrace
|
Defined in header
<stacktrace>
|
|
|
(C++23)
|
representation of an evaluation in a stacktrace
(class) |
|
(C++23)
|
approximate representation of an invocation sequence consists of stacktrace entries
(class template) |
Debugging support
|
Defined in header
<debugging>
|
|
|
(C++26)
|
pauses the running program when called
(function) |
|
(C++26)
|
calls
std::breakpoint
if
std::is_debugger_present
returns
true
(function) |
|
(C++26)
|
checks whether a program is running under the control of a debugger
(function) |
See also
static_assert
declaration
(C++11)
|
performs compile-time assertion checking |
|
C documentation
for
Error handling
|
|