CODEWITHSUNDEEP
c++exception
Suri
Suri

Reputation: 3357

why asynchronous events can not be handled using C ++ exceptions?

I was reading thinking in c++ (exceptional handling).

I didn't understand following line

C++ exceptions cannot be used to handle asynchronous events because the exception and its handler are on the same call stack.

I tried searching over web but couldn't able to under stand this line.(specially call stack part) Can anyone help on it?

EDIT: what does same call stack means?

Upvotes: 0

Views: 2656

Answers (4)

Sam Miller
Sam Miller

Reputation: 24174

The problem is like so

try {
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), {
        // do some really long running operation here
        longFunctionToCalculate42();

        // oops, some critical error!
        throw std::runtime_error( "Something went wrong!" );
    });
} catch ( const std::exception& e ) {
    // this won't do what you think it does
    std::cerr << e.what() << std::endl;
}

The asynchronous block is executed separately from the call site, and the caller of that asynchronous function (the dispatched block) cannot catch the exception thrown from it.

Upvotes: 1

SChepurin
SChepurin

Reputation: 1854

It means that asynchronous events do not follow the exception's model where "exception and its handler are on the same call stack". That is -

exceptions rely on the dynamic chain of function calls on the program s runtime stack (they have dynamic scope ), whereas asynchronous events must be handled by completely separate code that is not part of the normal program flow (typically, interrupt service routines or event loops)

Note "completely separate code", which means that you'd have to rely on some other mechanism to handle asynchronous events (if you really need so).

Upvotes: 0

John Dibling
John Dibling

Reputation: 101456

You actually can handle async events using exceptions. Weather or not you should is another matter. I'll only address that briefly: you usually shouldn't because there are more purpose-direct mechanisms to handle such things. Like passing messages between threads or raising some kind of event.

As to how you can accomplish this, what you have to do is catch the exception in the throw-ing thread, record the information somewhere, and have the other thread pick that up. Note that this really boils down fundamentally to passing messages between threads, with the additional complexity of stack unwinding and the like.

C++11 provides current_exception(), returning a exception_ptr, which provides the means to save the information about the exception somewhere the responding thread can pick it up. It is still up to you to build the code that actually retrieves and processes this exception_ptr up from wherever you saved it, and that's beyond the scope of this answer.

Note when thinking about this that, unless you need actual exceptions, doing this gains you nothing over simply passing messages between threads, and costs you the stack unwinding and semantic implications of throwing and catching exceptions.

Upvotes: 0

Paul Evans
Paul Evans

Reputation: 27577

Exceptions, when thrown, divert the current thread's execution path to the handling of that exception. There's no way to avoid this by, say, getting another thread to perform the exception handling. The stack is important here because the exception handling involves stack-unwinding which isn't conducive to asyncronouis event handling, or much else.

Upvotes: 2

Related Questions