Which data types can be thrown as exceptions in a c program?

Answer 1

C does not provide native support for exception handling.

There are basically three error handling strategies in C. The first is to design all functions such that the return value indicates success or failure. The second is to use an output parameter to indicate success or failure. The third is to set a global variable to indicate success or failure.

Integer values are usually used to indicate success or failure. Typically, the all-zeros bit-pattern indicates success while the all-ones bit pattern indicates failure (equating to 0 and -1, respectively, on a twos-complement system). However, any non-zero value can be used to indicate an error because all non-zero values implicitly convert to true (an error has occurred). Thus the error code can be used to indicate a specific type of error.

The problem with this is that there is often a lot of code between the point where an error is detected and the point where it can be handled. With global error codes this can be extremely problematic (particularly in multi-threaded applications) because the error code could easily change if other errors occur en-route to the error-handling code. But even for "local" return values and output parameters, this usually means storing the error code somewhere that the error-handling code can easily retrieve it. The only alternative is to deal with every error as and when it occurs, which is often impractical, but also leads to error handling code being duplicated and widely-dispersed.

In C++ we do not have these problems. If we invoke a C library function that returns or sets an error code that cannot be handled there and then, we can simply convert that code into an exception object and throw the object for a suitable handler to deal with. Once an exception is thrown by a thread, the call stack unwinds, immediately terminating functions (without returning a value) until a suitable handler is found. Unhandled exceptions that make it all the way back to the main function can be caught with a catch-all exception handler. By making consistent use of resource handles and "smart" pointer objects rather than "naked" pointers, all resources consumed between the error handling code and the point where the error was initially detected are automatically released, thus minimising the amount of manual housekeeping operations required en-route to the exception handling code. This technique is known by the unwieldy term Resource Acquisition Is Initialisation (RAII) but all this means is that named objects that utilise RAII will release their acquired resources automatically when they fall from scope.

As with exception-handling, RAII is not supported in C because objects in C have no constructors or destructors. When a "naked" pointer falls from scope, the object it was pointing at is not automatically released; it is up to the programmer to manually release the resource at the appropriate time. With multiple pointers referring to the same object (a shared resource), it can be difficult to determine which pointer actually "owns" the resource. With smart pointers we do not have this problem.