14 Exception handling [except]

14.1 Preamble [except.pre]

Exception handling provides a way of transferring control and information from a point in the execution of a thread to an exception handler associated with a point previously passed by the execution.

A handler will be invoked only by throwing an exception in code executed in the handler's try block or in functions called from the handler's try block.

try-block:
try compound-statement handler-seq

function-try-block:
try ctor-initializer

_{o p t}

compound-statement handler-seq

handler-seq:
handler handler-seq

_{o p t}

handler:
catch ( exception-declaration ) compound-statement

exception-declaration:
attribute-specifier-seq

_{o p t}

type-specifier-seq declarator
attribute-specifier-seq

_{o p t}

type-specifier-seq abstract-declarator

_{o p t}

...

The optional attribute-specifier-seq in an exception-declaration appertains to the parameter of the catch clause ([except.handle]).

A try-block is a statement ([stmt.pre]).

[Note 1:

Within this Clause “try block” is taken to mean both try-block and function-try-block.

— end note]

The compound-statement of a try block or of a handler is a control-flow-limited statement ([stmt.label]).

[Example 1: void f() { goto l1; // error goto l2; // error try { goto l1; // OK goto l2; // error l1: ; } catch (...) { l2: ; goto l1; // error goto l2; // OK } } — end example]

A goto, break, return, or continue statement can be used to transfer control out of a try block or handler.

When this happens, each variable declared in the try block will be destroyed in the context that directly contains its declaration.

[Example 2: lab: try { T1 t1; try { T2 t2; if (condition) goto lab; } catch(...) { /* handler 2 */ } } catch(...) { /* handler 1 */ }

Here, executing goto lab; will destroy first t2, then t1, assuming the condition does not declare a variable.

Any exception thrown while destroying t2 will result in executing handler 2; any exception thrown while destroying t1 will result in executing handler 1.

— end example]

A function-try-block associates a handler-seq with the ctor-initializer, if present, and the compound-statement.

An exception thrown during the execution of the compound-statement or, for constructors and destructors, during the initialization or destruction, respectively, of the class's subobjects, transfers control to a handler in a function-try-block in the same way as an exception thrown during the execution of a try-block transfers control to other handlers.

[Example 3: int f(int); class C { int i; double d; public: C(int, double); }; C::C(int ii, double id) try : i(f(ii)), d(id) { // constructor statements } catch (...) { // handles exceptions thrown from the ctor-initializer and from the constructor statements } — end example]

In this Clause, “before” and “after” refer to the “sequenced before” relation.