C: Correctly freeing memory of a multi-dimensional array

by

OK, there’s a fair deal of confusion explaining exactly what order the
necessary free() calls have to be in, so I’ll try to clarify what
people are trying to get at and why.

Starting with the basics, to free up memory which has been allocated
using malloc(), you simply call free() with exactly the pointer
which you were given by malloc(). So for this code:

int **a = malloc(m * sizeof(int *));

you need a matching:

free(a);

and for this line:

a[i]=malloc(n * sizeof(int));

you need a matching:

free(a[i]);

inside a similar loop.

Where this gets complicated is the order in which this needs to happen. If
you call malloc() several times to get several different chunks of
memory, in general it doesn’t matter what order you call free() when
you have done with them. However, the order is important here for a very
specific reason: you are using one chunk of malloced memory to hold
the pointers to other chunks of malloced memory. Because you must
not attempt to read or write memory once you have handed it back with
free(), this means that you are going to have to free the chunks with
their pointers stored in a[i] before you free the a chunk itself.
The individual chunks with pointers stored in a[i] are not dependent on each
other, and so can be freed in whichever order you like.

So, putting this all together, we get this:

for (i = 0; i < m; i++) { 
  free(a[i]);
}
free(a);

One last tip: when calling malloc(), consider changing these:

int **a = malloc(m * sizeof(int *));

a[i]=malloc(n * sizeof(int));

to:

int **a = malloc(m * sizeof(*a));

a[i]=malloc(n * sizeof(*(a[i])));

What’s this doing? The compiler knows that a is an int **, so it can
determine that sizeof(*a) is the same as sizeof(int *). However, if
later on you change your mind and want chars or shorts or longs or
whatever in your array instead of ints, or you adapt this code for later
use in something else, you will have to change just the one remaining
reference to int in the first quoted line above, and everything else
will automatically fall into place for you. This removes the likelihood
of unnoticed errors in the future.

Good luck!

More Related Contents:

  1. Create a wrapper function for malloc and free in C
  2. malloc implementation?
  3. Why do I get different results when I dereference a pointer after freeing it?
  4. Is freeing allocated memory needed when exiting a program in C
  5. Why exactly should I not call free() on variables not allocated by malloc()?
  6. How do malloc() and free() work?
  7. What REALLY happens when you don’t free after malloc before program termination?
  8. How can I get the size of an array from a pointer in C?
  9. How do free and malloc work in C?
  10. Setting variable to NULL after free
  11. Does free(ptr) where ptr is NULL corrupt memory?
  12. Why is malloc not “using up” the memory on my computer?
  13. How to dynamically allocate memory space for a string and get that string from user?
  14. Maximum memory which malloc can allocate
  15. Should I free memory before exit?
  16. free char*: invalid next size (fast) [duplicate]
  17. C – Accessing data AFTER memory has been free()ed?
  18. Explain this implementation of malloc from the K&R book
  19. If free() knows the length of my array, why can’t I ask for it in my own code?
  20. How do I free memory in C?
  21. Why do you specify the size when using malloc in C?
  22. dynamically allocated memory after program termination
  23. What happens if I try to access memory beyond a malloc()’d region?
  24. Problem usage memory in C
  25. Is free() zeroing out memory?
  26. How are we able to access the pointer after deallocating the memory?
  27. Code for malloc and free
  28. Is it safe to use realloc?
  29. new, delete ,malloc & free
  30. Determining Stack Space with Visual Studio

Leave a Comment