Thread: exception from C function?

Hello everyone,


As far as I know, C function does not throw exception.

But Bjarne said in his book, section 14.8 Exception and Efficiency,

--------------------
In particular, an implementation knows that only a few standard C library functions (such as atexit() and qsort()) can throw exceptions, and it can take advantage of that fact to generate better code.
--------------------

What did he mean? C function could really throw exception? What exception -- C++ exception or structured exception?


thanks in advance,
George

atexit() and qsort() accept arguments which are functions to pointers and, from a C++ perspective, there is nothing stopping the passed functions throwing exceptions.

Structured exceptions are a Microsoft-specific thing. There is nothing stopping a compiler targeting a windows OS from doing things with structured exceptions. But that is unrelated to Bjarne's comments.

Bjarne was referring to the fact that, as specified, most standard C functions have no reason to throw exceptions and do not call any function that might throw exceptions. This means that, even though standard C functions have no exception specifications (which, from a C++ perspective, means they can throw ANY exception) a C++ compiler can still take advantage of the fact they won't throw exceptions.

Thanks grumpy,


1. If C library function qsort() takes a C++ function as callback parameter, and the C++ callback function throws exception, how could the C library function qsort() handls a C++ exception?

2. If there are exceptions in the C++ callback function, and the C++ callback function catches the exception by itself, and never throws it again -- but returns error code to C function qsort() since C function can not handle C++ exception. If this is the case, I think it is not what Bjarne's point, since in this situation, there is no exception thrown from qsort() C library function.

Any comments?

Originally Posted by grumpy

atexit() and qsort() accept arguments which are functions to pointers and, from a C++ perspective, there is nothing stopping the passed functions throwing exceptions.

Structured exceptions are a Microsoft-specific thing. There is nothing stopping a compiler targeting a windows OS from doing things with structured exceptions. But that is unrelated to Bjarne's comments.

Bjarne was referring to the fact that, as specified, most standard C functions have no reason to throw exceptions and do not call any function that might throw exceptions. This means that, even though standard C functions have no exception specifications (which, from a C++ perspective, means they can throw ANY exception) a C++ compiler can still take advantage of the fact they won't throw exceptions.

regards,
George

Thanks Elysia,


I am interested in how C code could keep the status elegant (example, no resource leak and no crash) when it calls a C++ function and the C++ function throws an exception. Since C has no approach to detect whether a C++ exception is thrown, even it has no cencept of what an exception is, how C code could make the status elegant looks mysterious to me... :-)

It is appreciated if you could give more description or recommend some learning resource (to save your time). :-)

Originally Posted by Elysia

Well, perhaps, as you say, the qsort can throw an exception in that the C++ callback function it calls can throw an exception. Therefore you should take into mind that while a C function itself may never throw an exception, if it callbacks to a C++ function, the function can throw an exception because the execution is inside or beyond the qsort function. So you should keep in mind that a few C function could throw an exception (if not handled by the C++ callback function).

regards,
George

Hi Elysia,


Sorry for my bad English. :-)

I do not understand how to translate "screwed" into an elegant and form term in C++ or C world. Could you express your point in some other statements please?

Originally Posted by Elysia

From what I see, it can't. C wasn't designed for C++ in mind, so if the C++ function throws anything, the C function is screwed if it needs to clean up anything but stack variables.

regards,
George

Thanks Elysia,


Could I understand your point in the following way?

when there is exception in C++ callback code called from C code qsort(), runtime will looks for the handler of the exception and since C qsort() has no exception handler, it will jump to the higher address of the stack (higher than qsort()), maybe the called of the qsort() to seek for exception handlers.

So, for local variables in C qsort(), it is ok during stack unwinding, but for other resources, there may be leak.

My understanding correct?

Originally Posted by Elysia

You know what happens when an exception is thrown and caught outside the function. If the exception is caught in your C++ code outside qsort for example. The function never has a chance to clean up because the compiler will simply jump to your catch block without executing code in the C function, so it can't clean up. If it only uses stack variables, it will be fine, but not if it does something else.

regards,
George

Thanks Elysia,


You are so patient and knowable. My question is answered. :-)

Originally Posted by Elysia

Yes.

regards,
George

Originally Posted by CornedBee

Code compiled with a C compiler doesn't know about exceptions.

This is completely true. It's probably worth noting, however, that Bjarne's comments were in the context of a compiler (or, more accurately, the developer of the compiler) being aware of requirements associated with C++. For example, if the C standard library is compiled from source with a C++ compiler.

Originally Posted by CornedBee

The actual rule is simple: catch all C++ exceptions at the end of a callback and use the callback's error reporting mechanism (typically a return code) to report the error. The callback doesn't have such a mechanism? (qsort's callback for example) Then there probably shouldn't be any errors. (How hard can comparing two objects be?)

This could probably be used to support a position - in a future version of the C++ standard, for example - that callbacks passed to qsort() yield undefined behaviour if they throw an exception. The C standard need specify nothing, as no standard-compliant C code can throw an exception anyway.

I suspect a similar argument might also be valid for atexit() callbacks. After all, in what circumstances would someone want to throw an exception in the process of exiting from a program?