Lifecycle of thrown exceptions in C++

Question

Consider the following simple C++ code:

void foo() {
    throw(my_exception());
}

void check_exc(const my_exception &exc) {
    /* Do stuff with exc */
}

void bar() {
    try {
        foo();
    } catch(const my_exception &exc) {
        check_exc(exc);
    }
}

In bar's exception handler, how comes the exception referenced by exc is still alive, seeing as how it was allocated in foo's stack frame? Shouldn't that frame have been unwound by the time the exception handler gets to run, and any values allocated there already be considered dead? Especially so since I'm explicitly calling another function which would need that stack space.

As a C programmer trying to learn C++, what am I misunderstanding here? Where do these various values actually exist in memory, more precisely?

Exceptions are treated specially to allow this. I would say you are not misunderstanding anything, merely that you didn't know about this special rule :) — Magnus Hoff, Sep 19 '14 at 13:43
Check this out: http://stackoverflow.com/questions/12999448/exception-object-lifetime — bfair, Sep 19 '14 at 13:43
The thing with exceptions is that they are *exceptional*. :) That means they are treated specially by the compiler and runtime environment to make sure they don't go out of scope. — Some programmer dude, Sep 19 '14 at 13:43
Read Scott Meyer's _More Effective C++ - Item 13: Catch exceptions by reference_, where he discusses how this works and why you should prefer `catch (my_exception &exc) {}` over other forms. — Alex MDC, Sep 19 '14 at 13:47
@AlexMDC: assuming you have correctly reproduced Scott's advice, it is bogus. instead of `catch (my_exception &exc) {}` do `catch (my_exception const& exc ) {}`. stronger guarantees, more constraints, less that can go wrong. — Cheers and hth. - Alf, Sep 19 '14 at 13:56
Possible duplicate of [Scope of exception object in C++](https://stackoverflow.com/questions/1654150/scope-of-exception-object-in-c) — anton_rh, Dec 18 '18 at 05:34

Mike Seymour · Accepted Answer · 2014-09-19T13:57:59.227

8

The temporary created in the throw-expression is used to initialise the exception object itself, which (to quote the standard) "is allocated in an unspecified way". That object lasts (at least) until the exception has been handled, so the handler's reference to it is valid within the handler, or any function called from the handler.

edited Sep 19 '14 at 13:57

answered Sep 19 '14 at 13:45

Mike Seymour

249,747
28
448
644

re " That object lasts until the exception has been handled", its guaranteed existence can be much longer than that. – Cheers and hth. - Alf Sep 19 '14 at 13:49
1

@Cheersandhth.-Alf: Indeed, you could use an `exception_ptr` to extend its lifetime beyond that of the handler. But that's rather beyond the scope of this question. – Mike Seymour Sep 19 '14 at 13:53
also (nit mode), there needs not be any "temporary created in the throw expression". you could rescue that by rewriting the para. possibly. – Cheers and hth. - Alf Sep 19 '14 at 13:59
1

@Cheersandhth.-Alf: Yes, I considered adding a digression into copy/move elision, but thought it better to keep the answer simple and focused on the question of the lifetime of the exception object itself. – Mike Seymour Sep 19 '14 at 14:01

Cheers and hth. - Alf · Answer 2 · 2014-09-19T14:01:46.880

Exceptions are thrown by value.

That is, the specified object is copied (possibly sliced, as with any copy initialization) or moved.

The exception object that you can reference via e.g. a catch clause's reference parameter, is not allocated in the original throwing code's stack frame, but in “an unspecified way”.

In C++11 the possible ways that exception objects could be allocated (internally in the run time library) was restricted, by the requirement that exception objects could be referenced by essentially shared ownership smart pointers, std::exception_ptr.

The possibility of shared ownership means that in C++ an exception object can have a guaranteed lifetime beyond the completed handling of the exception.

This is mainly in support of passing exceptions through non-exception-aware C code, and in order to pass nested exception information.

score 1 · Answer 3 · answered Sep 19 '14 at 13:46

The implementation would vary from platform to platform. The life cycle is more complicated that one might imagine since the throw statement starts executing in the stack frame of foo().

It's possible that the exception object gets copies and reallocated, or the catch block might execute in a frame on top of foo but with a pointer to the bar frame in order to reference bar's variables.

score 0 · Answer 4 · answered Sep 19 '14 at 13:48

He,

the line

 throw(my_exception())

generates a new object of the type my_exception. You can specify whatever you want (int, enums, char * or classes). Of course, Classes make more sense as you can define additional data to it.

After this, the whole stack will be cleaned up and all recursions are terminated until it gets to the first try/catch block. The exception is still alive there. The code in the catch block is just like implementing a if/else block, just a little smarter.

cheers,

Lifecycle of thrown exceptions in C++

4 Answers4

Linked