Error handling

 

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)

 

Exception handling

The header <exception> provides several classes and functions related to exception handling in C++ programs.

Defined in header <exception>
exception	base class for exceptions thrown by the standard library components (class)
Capture and storage of exception objects
uncaught_exceptionuncaught_exceptions (C++17)	checks if exception handling is currently in progress (function)
exception_ptr (C++11)	shared pointer type for handling exception objects (typedef)
make_exception_ptr (C++11)	creates an std::exception_ptr from an exception object (function template)
current_exception (C++11)	captures the current exception in a std::exception_ptr (function)
rethrow_exception (C++11)	throws the exception from an std::exception_ptr (function)
nested_exception (C++11)	a mixin type to capture and store current exceptions (class)
throw_with_nested (C++11)	throws its argument with std::nested_exception mixed in (function template)
rethrow_if_nested (C++11)	throws the exception from a std::nested_exception (function template)
Handling of failures in exception handling
terminate	function called when exception handling fails (function)
terminate_handler	the type of the function called by std::terminate (typedef)
get_terminate (C++11)	obtains the current terminate_handler (function)
set_terminate	changes the function to be called by std::terminate (function)
Handling of exception specification violations
unexpected (deprecated)	function called when dynamic exception specification is violated (function)
bad_exception	exception thrown when dynamic exception specification is violated, if possible (class)
unexpected_handler (deprecated)	the type of the function called by std::unexpected (typedef)
get_unexpected (C++11)(deprecated)	obtains the current unexpected_handler (function)
set_unexpected (deprecated)	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 can not be easily predicted.

Defined in header <stdexcept>
logic_error	exception class to indicate violations of logical preconditions or class invariants (class)
invalid_argument	exception class to report invalid arguments (class)
domain_error	exception class to report domain errors (class)
length_error	exception class to report attempts to exceed maximum allowed size (class)
out_of_range	exception class to report arguments outside of expected range (class)
runtime_error	exception class to indicate conditions only detectable at run time (class)
range_error	exception class to report range errors in internal computations (class)
overflow_error	exception class to report arithmetic overflows (class)
underflow_error	exception class to report arithmetic underflows (class)

Error numbers

Defined in header <cerrno>
errno	macro which expands to POSIX-compatible thread-local error number variable (macro variable)
E2BIG, EACCES, ..., EXDEV	macros for standard POSIX-compatible error conditions (macro constant)

Assertions

Assertions help to implement checking of preconditions in programs.

static assertion

performs compile-time assertion checking (since C++11)

Defined in header <cassert>
assert	aborts the program if the user-specified condition is not true. May be disabled for release builds (function macro)

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>
error_category (C++11)	base class for error categories (class)
generic_category (C++11)	identifies the generic error category (function)
system_category (C++11)	identifies the operating system error category (function)
error_condition (C++11)	holds a portable error code (class)
errc (C++11)	the std::error_condition enumeration listing all standard <cerrno> macro constants (class)
error_code (C++11)	holds a platform-dependent error code (class)
system_error (C++11)	exception class used to report conditions that have an error_code (class)

See also

C documentation for Error handling