C Error Handling Library
Contents |
here for a quick overview of the site Help Center Detailed answers to any questions you might have Meta Discuss the workings and policies of this site About Us Learn more about Stack Overflow the company Business objective c error handling Learn more about hiring developers or posting ads with us Stack Overflow Questions Jobs Documentation
C Error Handling Goto
Tags Users Badges Ask Question x Dismiss Join the Stack Overflow Community Stack Overflow is a community of 4.7 million programmers, just like
Objective C Error Handling Best Practices
you, helping each other. Join them; it only takes a minute: Sign up Error handling in C code up vote 102 down vote favorite 59 What do you consider "best practice" when it comes to error handling
Error Handling Functions In C
errors in a consistent way in a C library. There are two ways I've been thinking of: Always return error code. A typical function would look like this: MYAPI_ERROR getObjectSize(MYAPIHandle h, int* returnedSize); The always provide an error pointer approach: int getObjectSize(MYAPIHandle h, MYAPI_ERROR* returnedError); When using the first approach it's possible to write code like this where the error handling check is directly placed on the function call: int size; if(getObjectSize(h, &size) != MYAPI_SUCCESS) error handling in c language { // Error handling } Which looks better than the error handling code here. MYAPIError error; int size; size = getObjectSize(h, &error); if(error != MYAPI_SUCCESS) { // Error handling } However, I think using the return value for returning data makes the code more readable, It's obvious that something was written to the size variable in the second example. Do you have any ideas on why I should prefer any of those approaches or perhaps mix them or use something else? I'm not a fan of global error states since it tends to make multi threaded use of the library way more painful. EDIT: C++ specific ideas on this would also be interesting to hear about as long as they are not involving exceptions since it's not an option for me at the moment... c error-handling share|improve this question edited Nov 6 '13 at 19:09 ubershmekel 3,61513144 asked Dec 22 '08 at 10:46 Laserallan 6,70172956 add a comment| 17 Answers 17 active oldest votes up vote 49 down vote accepted I like the error as return-value way. If you're designing the api and you want to make use of your library as painless as possible think about these additions: store all possible error-states in one typedef'ed enum and use it in your lib. Don't just return ints or even worse, mix ints or different
of a library call. The functions strerror and perror give you the standard error message for a given error code; the variable program_invocation_short_name gives error handling c programming you convenient access to the name of the program that encountered the cocoa error handling error. Function: char * strerror (int errnum) Preliminary: | MT-Unsafe race:strerror | AS-Unsafe heap i18n | AC-Unsafe mem | ruby error handling See POSIX Safety Concepts. The strerror function maps the error code (see Checking for Errors) specified by the errnum argument to a descriptive error message string. The return value is http://stackoverflow.com/questions/385975/error-handling-in-c-code a pointer to this string. The value errnum normally comes from the variable errno. You should not modify the string returned by strerror. Also, if you make subsequent calls to strerror, the string might be overwritten. (But it’s guaranteed that no library function ever calls strerror behind your back.) The function strerror is declared in string.h. Function: char * strerror_r (int http://www.gnu.org/s/libc/manual/html_node/Error-Messages.html errnum, char *buf, size_t n) Preliminary: | MT-Safe | AS-Unsafe i18n | AC-Unsafe | See POSIX Safety Concepts. The strerror_r function works like strerror but instead of returning the error message in a statically allocated buffer shared by all threads in the process, it returns a private copy for the thread. This might be either some permanent global data or a message string in the user supplied buffer starting at buf with the length of n bytes. At most n characters are written (including the NUL byte) so it is up to the user to select a buffer large enough. This function should always be used in multi-threaded programs since there is no way to guarantee the string returned by strerror really belongs to the last call of the current thread. The function strerror_r is a GNU extension and it is declared in string.h. Function: void perror (const char *message) Preliminary: | MT-Safe race:stderr | AS-Unsafe corrupt i18n heap lock | AC-Unsafe corrupt lock mem fd | See POSIX Safety Concepts. This function prints an error message to the stream stderr; s
handling in C Posted on January 16, 2010 by rlc One of the things I do as a analyst-programmer is write software - that would be the "programmer" part. I usually do that in C++ but, sometimes, when the http://rlc.vlinder.ca/blog/2010/01/error-handling-in-c/ facilities of C++ aren't available (e.g. no exception handling and no RTTI) C becomes a more obvious choice. When that happens, RTTI is not the thing I miss the most - you can get around http://www.on-time.com/ddj0011.htm that using magic numbers if you need to. Exceptions, on the other hand, become a very painful absence when you're used to using them. Error handling is a very important part of programming: a lot error handling of things can go wrong when a program runs and most of those things need to be handled properly because the functionalities of your program depend on them. C++ uses exceptions for this purpose, so that if a call to foo fails, you don't have to handle that failure in the context of your call - especially if you wouldn't be able to do anything about it anyway. Thus, c error handling the following code: foo(); bar(); will call bar only if foo didn't throw any exceptions. Presumably both do something useful and neither of them return anything useful. Now, the same thing would be true in C if we did something like this: int result = foo(); if (result == 0) result = bar(); Now, both foo and bar return a result code which, in this case, is 0 if all is well. Windows programmers will be more familiar with this: HRESULT result = foo(); if (SUCCEEDED(result)) result = bar(); which amounts to the same thing. HRESULT, after all, is a 32-bit unsigned integer of which a few bits are reserved to indicate where the error originated and the other bits indicate the error. An HRESULT value of 0 means no error, so the SUCCEEDED basically checks whether the result is 0. The trouble starts when the function returned an integer already - e.g. a getFooCount function: unsigned int foo_count(getFooCount()); foo(foo_count); In this code, foo only gets called when getFooCount returns a valid value - which is the function's post-condition, so it would have thrown an exception otherwise. There are two different ways to port this to C: unsigned int foo_count = getFooCount(); if (isValidFooCount(foo_count)) foo(foo_count); or: unsig
Peter Petersen Error handling is an important issue in embedded systems, and it can account for a substantial portion of a project's code. We were faced with this issue during the design of RTFiles, the embedded filesystem component of On Time RTOS-32, our Win32-compatible RTOS for 32-bit x86 targets. The core filesystem is portable with a C function API to the application and a device-driver interface below it. Typically, errors can occur in device drivers and must be reported to the application with suitable return codes, so errors must travel through the complete core filesystem. The classic C approach to this problem is return codes. Each function returns a value indicating success or failure. However, with a nontrivial function call hierarchy, this approach clutters the code significantly. Every function must check the return code of every function call it makes and take care of errors. In most cases, the function will merely pass any errors back up to its caller. RTFiles has several hundred internal functions and a call hierarchy up to about 15 levels deep, so this approach would have been a nightmare to maintain. Programming languages such as Ada or C++ address this issue with exceptions. Exceptions make it easy to separate error handling from the rest of the code. Intermediate functions can completely ignore errors occurring in functions they call, if they can't handle them anyway. Exceptions are much easier to maintain than error return codes, so we definitely wanted to use them for RTFiles. Unfortunately, we had to write RTFiles in C, and not C++ or Ada, for portability. RTFiles must support compilers without C++ support. Another issue is overhead and reliability. C++ exception handling needs a lot of run-time system support routines, which might add too much code to a small embedded system. C++ exceptions are objects dynamically allocated from the heap, but many embedded systems do not want to use any dynam