What happens if exception gets thrown “through” c code? [duplicate]

Answer 1

C doesn't know anything about exceptions so it's not possible to say what would happen.

To write conforming code you'd need to catch exceptions prior to returning into the C library, translate to error codes, and then translate the C-library error back into an exception on the other end.

Answer 2

It is entirely up to the compiler if this will work or not. None of the language standards can obviously say anything about what the other language should do.

In the best case, the exception will pass the C code and get back to the next C++ level while possibly leaking any dynamically allocated C structures. In the less good case, it will crash and burn!

One possibilty is of course to compile the C code as C++, while also checking that it is exception neutral.

Answer 3

The answer to your question is implementation-defined.

For GCC, as @Kerrek says, compiling the C code with -fexceptions will ensure the run-time remains consistent when an exception is thrown through C code. (Note that modern exception mechanisms are not just implemented via setjmp/longjmp; they actually unwind the stack frame by frame in order to handle destructors and try/catch blocks properly.)

However, the C code itself may not be expecting to have exceptions thrown through it. Lots of C code is written like this:

acquire a resource
do some stuff
release resource

Here "acquire a resource" could mean malloc, or pthread_mutex_lock, or fopen. If your C++ code is part of the "do some stuff", and it throws an exception, well... Whoops.

Resource leaks are not the only problem; so is correctness is general. Imagine:

subtract $100 from savings account
add $100 to checking account

Now imagine an exception gets thrown after the first step finishes but before the second one does.

In short, although your implementation may provide a way to let you throw exceptions through C code, it is a bad idea unless you also wrote that C code knowing exactly where an exception might be thrown.

Answer 4

It's okay for your C++ code if it's:

1. Compiled with exceptions enabled.
2. Exception safe.

It's okay for your C or C++ code if:

1. No resources need to be collected explicitly between the throwing of the exception, and its being caught.

Code compiled with C++ exception support adds special hooks to clean up when exceptions are thrown and not caught in that scope. C++ objects allocated on the stack will have their destructors invoked.

The only resource reclaimed in C (or C++ without exception support) when an exception is thrown is the space allocated in each stack frame.

This section of the GCC manual is quite helpful:

       -fexceptions
           Enable exception handling.  Generates extra code needed to
           propagate exceptions.  For some targets, this implies GCC will
           generate frame unwind information for all functions, which can
           produce significant data size overhead, although it does not affect
           execution.  If you do not specify this option, GCC will enable it
           by default for languages like C++ which normally require exception
           handling, and disable it for languages like C that do not normally
           require it.  However, you may need to enable this option when
           compiling C code that needs to interoperate properly with exception
           handlers written in C++.  You may also wish to disable this option
           if you are compiling older C++ programs that don't use exception
           handling.

Answer 5

Exceptions aren't usually really thrown "through" code; as the action implies, they are thrown "over" code.

As a forinstance; at least old-school Objective-C exceptions are usually implemented with setjmp and longjmp; essentially storing the addresses of code for later use.

It makes sense for C++ exceptions to be implemented with similar mechanisms; and as such; the type of code the exception is thrown "through", or more accurately, "over" matters little, if at all. One could even imagine a setting where an Objective-C exception is thrown over a C++ catch, or vice versa.

Edit: As Bo Persson mentiones; this is not to say that a C++ exception interrupting C code wouldn't cause havoc and leaks; but exceptions being thrown is usually a Bad Thing™ all round; so it's not likely to matter much.

PS: Kudos on actually asking a question where using both C and C++ tags is relevant. ;)