How to check multiple mallocs and free them if error?

Question

I have a program where I use a lot of mallocs (and other similar functions) to allocate memory for different datatypes. As we know this functions may fail. How can I write a neat code for checking if memory was successfully allocated, and if not, freeing all the previous mallocs, if any?

I thought maybe writing a function that frees every pointer I malloc, if they are != NULL. But then I will need to send a lot of parameters. Any better ideas?

Thanks.

Answer 1

This is actually a non-trivial C coding idiom question. One answer is to learn C++ and use auto_pointer.

In C, I've had success with the following idiom.

1. Set all pointers to NULL upon declaration.
2. Allocate memory only as it's needed.
3. If an allocation fails, set an error value and goto a label at the end where all pointers are freed.
4. If for some reason you need to free a pointer early, set it NULL again.
5. All normal executions must fall through to the end so that everything is freed (no intermediate return).

It ends up looking like this:

int err = 0;
FOO *p = NULL; 
BAR *q = NULL; 
BAZ *r = NULL;

p = malloc(...);
if (!p) {
  err = P_MALLOC_FAILURE;
  goto done;
}
....
q = malloc(...);
if (!q) {
  err = Q_MALLOC_FAILURE;
  goto done;
}
....
// Done with p.  Free it early.
free(p);
p = NULL;
....
done:
  free(p);
  free(q);
  return err;

The definition of free ensures nothing happens if a pointer is still NULL at the end. If you don't like the repeated code, you can abuse a macro:

#define ALLOC_OR_FAIL(P) do { \
  P = malloc(sizeof *P); \
  if (!P) { \
    err = P ## _MALLOC_FAILURE; \
    goto done; \
  } } while (0)

Answer 2

Well, you could design your code in such a way that if there is an error then your program flow works its way back up the call stack and all your functions free their allocated memory when they are returning an error condition.

If your code is not that well organized, then the only portable way to "neatly" free all the previous mallocs is if you store a global table of mallocs as you do them, that you keep up to date every time you call malloc or free (or any other allocating function).

However, modern operating systems free all the memory for you on process exit, and in fact they can do this a lot faster than you can because they can just free the entire process's memory allocation in one go. IMHO a practical decision would be to just exit without explicitly freeing unless you suspect that your code will be run on a system where that would leak memory.

Answer 3

Just like pzaenger said...

ptr = calloc/malloc/realloc(parameters);

if(ptr == NULL)
{
    printf("Well shucks...");
}

Simple enough.

I've been building on some code and I too have a lot of parameters to it 7/8 at the moment, with most of them being pointers that are dereferenced and so on.

I have a few functions, with more on the way, that use these same 7/8 parameters. So to clean them up, I am simply going to stuff them into a structure(c struct). That way, all I have to do is pass a single parameter, the struct(or more than likely a ptr to the struct).

All you have to do now at the beginning, is malloc/calloc memory for the struct, then malloc/calloc memory for any pointers inside the struct.

Then you pass that struct to and fro, doing whatever it is you need to do.

In the end, you go through the struct and free up any memory malloc/calloc'ed inside of it. Then free up the memory(if a ptr to the struct was used) for the struct itself.