Exception handling provides a way of transferring control and information from some point in the execution of a program to a handler associated with a point previously passed by the execution (in other words, exception handling transfers control up the call stack).

Evaluating athrow expression will throw an exception. Exceptions can also be thrown inother contexts.

In order for an exception to be caught, thethrow expression has to be inside atry block, and thetry block has to contain ahandler that matches the type of the exception object.

When declaring a function, the following specification(s) may be provided to limit the types of the exceptions a function may throw:

Errors that arise during exception handling are handled bystd::terminate andstd::unexpected(until C++17).

[edit]Usage

Whilethrow expression can be used to transfer control to an arbitrary block of code up the execution stack, for arbitrary reasons (similar tostd::longjmp), its intended usage is error handling.

[edit]Error handling

Throwing an exception is used to signal errors from functions, where "errors" are typically limited to only the following^[1][2][3]:

1. Failures to meet the postconditions, such as failing to produce a valid return value object.
2. Failures to meet the preconditions of another function that must be called.
3. (for non-private member functions) Failures to (re)establish a class invariant.

In particular, this implies that the failures of constructors (see alsoRAII) and most operators should be reported by throwing exceptions.

In addition, so-calledwide contract functions use exceptions to indicate unacceptable inputs, for example,std::basic_string::at has no preconditions, but throws an exception to indicate index out of range.

[edit]Exception safety

After the error condition is reported by a function, additional guarantees may be provided with regards to the state of the program. The following four levels of exception guarantee are generally recognized^[4][5][6], which are strict supersets of each other:

1. Nothrow (or nofail) exception guarantee — the function never throws exceptions. Nothrow (errors are reported by other means or concealed) is expected ofdestructors and other functions that may be called during stack unwinding.Thedestructors arenoexcept by default.(since C++11) Nofail (the function always succeeds) is expected of swaps,move constructors, and other functions used by those that provide strong exception guarantee.
2. Strong exception guarantee — If the function throws an exception, the state of the program is rolled back to the state just before the function call (for example,std::vector::push_back).
3. Basic exception guarantee — If the function throws an exception, the program is in a valid state. No resources are leaked, and all objects' invariants are intact.
4. No exception guarantee — If the function throws an exception, the program may not be in a valid state: resource leaks, memory corruption, or other invariant-destroying errors may have occurred.

Generic components may, in addition, offerexception-neutral guarantee: if an exception is thrown from a template parameter (e.g. from theCompare function object ofstd::sort or from the constructor ofT instd::make_shared), it is propagated, unchanged, to the caller.

[edit]Exception objects

While objects of any complete type and cv pointers tovoid may be thrown as exception objects, all standard library functions throw unnamed objects by value, and the types of those objects are derived (directly or indirectly) fromstd::exception. User-defined exceptions usually follow this pattern.^[7][8][9]

To avoid unnecessary copying of the exception object and object slicing, the best practice for handlers is to catch by reference.^{[10][11][12][13]}

[edit]Notes

[edit]External links

• In other languages

• Español
• 日本語
• Русский
• 中文