14 Exception handling [except]

14.3 Constructors and destructors [except.ctor]

As control passes from the point where an exception is thrown to a handler, objects are destroyed by a process, specified in this subclause, called stack unwinding.

Each object with automatic storage duration is destroyed if it has been constructed, but not yet destroyed, since the try block was entered.

If an exception is thrown during the destruction of temporaries or local variables for a return statement ([stmt.return]), the destructor for the returned object (if any) is also invoked.

The objects are destroyed in the reverse order of the completion of their construction.

[Example 1: struct A { }; struct Y { ~Y() noexcept(false) { throw 0; } }; A f() { try { A a; Y y; A b; return {}; // #1 } catch (...) { } return {}; // #2 }

At #1, the returned object of type A is constructed.

Then, the local variable b is destroyed ([stmt.jump]).

Next, the local variable y is destroyed, causing stack unwinding, resulting in the destruction of the returned object, followed by the destruction of the local variable a.

Finally, the returned object is constructed again at #2.

— end example]

If the initialization of an object other than by delegating constructor is terminated by an exception, the destructor is invoked for each of the object's subobjects that were known to be initialized by the object's initialization and whose initialization has completed ([dcl.init]).

[Note 1:

If such an object has a reference member that extends the lifetime of a temporary object, this ends the lifetime of the reference member, so the lifetime of the temporary object is effectively not extended.

— end note]

A subobject is known to be initialized if its initialization is specified

(3.1)
in [class.base.init] for initialization by constructor,
(3.2)
in [class.copy.ctor] for initialization by defaulted copy/move constructor,
(3.3)
in [class.inhctor.init] for initialization by inherited constructor,
(3.4)
in [dcl.init.aggr] for aggregate initialization,
(3.5)
in [expr.prim.lambda.capture] for the initialization of the closure object when evaluating a lambda-expression,
(3.6)
in [dcl.init.general] for default-initialization, value-initialization, or direct-initialization of an array.

[Note 2:

This includes virtual base class subobjects if the initialization is for a complete object, and can include variant members that were nominated explicitly by a mem-initializer or designated-initializer-clause or that have a default member initializer.

— end note]

If the destructor of an object is terminated by an exception, each destructor invocation that would be performed after executing the body of the destructor ([class.dtor]) and that has not yet begun execution is performed.

[Note 3:

This includes virtual base class subobjects if the destructor was invoked for a complete object.

— end note]

The subobjects are destroyed in the reverse order of the completion of their construction.

Such destruction is sequenced before entering a handler of the function-try-block of the constructor or destructor, if any.

If the compound-statement of the function-body of a delegating constructor for an object exits via an exception, the object's destructor is invoked.

Such destruction is sequenced before entering a handler of the function-try-block of a delegating constructor for that object, if any.

[Note 4:

If the object was allocated by a new-expression ([expr.new]), the matching deallocation function, if any, is called to free the storage occupied by the object.

— end note]