What are the possible errors that can occur during memory allocation using malloc except out of memory? What are the best strategies to handle those errors?
For an out of memory exception is it necessary to free the pointer even if memory allocation fails?
In C there are no exceptions (not you can use in the language anyway), so the only way malloc can signal failure is returning a null pointer. So you have to check the return value. If it is 0, allocation failed (for whatever reason) and no memory allocated - nothing to free; otherwise allocation for the requested amount(*) succeeded and you will have to free the memory when no longer needed.
(*) beware of overflows: malloc takes a size_t parameter, which is most likely an unsigned number. If you request size * sizeof(int) bytes with an unsigned size and the multiplication overflows (possibly an error in obtaining the value of size), the result is a small number. malloc() will allocate this small number of bytes for you returning with non-null and you index into the returned array based on the actual (large) value of size, possibly resulting in segmentation fault or its equivalent
I realize this looks like a product plug, but you can read about various kinds of memory allocation errors in our writeup on CheckPointer, our tool for finding memory management errors, including such allocation mistakes.
Out of memory is the only detectable error ... other errors such as freeing memory that has already been freed can lead to crashes.
One strategy for out of memory checking in C is to use wrappers for malloc and realloc (you could possibly call them xmalloc and xrealloc) that check for out of memory and if so take an error action ... printing a message and exiting, or possibly trying to free memory pools and then retrying the allocation. This puts all the testing in one place, produces consistent failure messages, and guarantees that all allocation attempts are checked for failure. Possible downsides are discussed in the comments below.
Historically, this strategy was rare in C code (consistent with a general low quality throughout the code written in this ancient language), but nowadays some mature library frameworks incorporate this sort of thing (although the implementations leave something to desire; again, see comments below). Another approach, which is highly advisable, is to abandon C and move to a more modern language ... possibly C++, in which any failure of new results in a bad_alloc exception.
As for your question ... if malloc fails, it returns NULL; there is no pointer to free. (free(NULL) is a no-op). If realloc fails, then the original allocation remains unchanged. You can find these things out by reading the manual pages or specifications such as http://pubs.opengroup.org/onlinepubs/7908799/xsh/realloc.html
malloc are an extremely harmful but pervasive programming practice that needs to be abolished. There's no getting around it -- you have to handle failure of malloc, and there's no "easier" way to handle it that can be achieved with a wrapper. Wrappers that just abort the program make it easy to write broken code that doesn't check for malloc failure (because it can assume your wrapper never returns failure) and it becomes nearly impossible to fix/retro-fit this broken code to be usable in robust software. Major libraries like GMP and glib suffer from this issue.
malloccall can succeed, but the memory isn't actually available and your process gets killed. The operating system oversubscribes memory by default. It isn't usually a big issue.echo "2" > /proc/sys/vm/overcommit_memory)