Difference between revisions of "cpp/error"
From cppreference.com
< cpp
Andreas Krug (Talk | contribs) m (fmt) |
(~ -> diagnostics library + add debugging) |
||
| (One intermediate revision by one user not shown) | |||
| Line 1: | Line 1: | ||
| − | {{title| | + | {{title|Diagnostics library}} |
{{cpp/error/navbar}} | {{cpp/error/navbar}} | ||
===Exception handling=== | ===Exception handling=== | ||
| − | The header {{ | + | The header {{header|exception}} provides several classes and functions related to exception handling in C++ programs. |
{{dsc begin}} | {{dsc begin}} | ||
| Line 24: | Line 24: | ||
{{dsc inc|cpp/error/dsc set_terminate}} | {{dsc inc|cpp/error/dsc set_terminate}} | ||
{{dsc inc|cpp/error/dsc bad_exception}} | {{dsc inc|cpp/error/dsc bad_exception}} | ||
| − | {{dsc h2|Handling of exception specification violations | + | {{dsc h2|Handling of exception specification violations {{mark until c++17|removed=yes}}}} |
{{dsc inc|cpp/error/dsc unexpected}} | {{dsc inc|cpp/error/dsc unexpected}} | ||
{{dsc inc|cpp/error/dsc unexpected_handler}} | {{dsc inc|cpp/error/dsc unexpected_handler}} | ||
| Line 82: | Line 82: | ||
{{dsc inc|cpp/utility/dsc stacktrace_entry}} | {{dsc inc|cpp/utility/dsc stacktrace_entry}} | ||
{{dsc inc|cpp/utility/dsc basic_stacktrace}} | {{dsc inc|cpp/utility/dsc basic_stacktrace}} | ||
| + | {{dsc end}} | ||
| + | |||
| + | ===Debugging support=== | ||
| + | {{dsc begin}} | ||
| + | {{dsc header|debugging}} | ||
| + | {{dsc inc|cpp/utility/dsc breakpoint}} | ||
| + | {{dsc inc|cpp/utility/dsc breakpoint_if_debugging}} | ||
| + | {{dsc inc|cpp/utility/dsc is_debugger_present}} | ||
{{dsc end}} | {{dsc end}} | ||
Latest revision as of 20:54, 30 October 2024
Contents |
[edit] 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) |
[edit] 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) |
[edit] 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) | |
[edit] 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) |
[edit] 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) | |
[edit] 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) |
[edit] 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) |
[edit] See also
static_assert declaration (C++11)
|
performs compile-time assertion checking |
| C documentation for Error handling
| |
