How to properly free char** in C

Question

I have really been confused about this 2D char array

char **arg = malloc(sizeof(char*) * argc)
for (int i = 0; i < argc; i++)
  arg[i] = malloc(sizeof(char) * size)
...
...

Now suppose after a series of operations, I forget the variable argc, how can I free those memory? Can I do something like this? Is this absolutely correct under all circumstances?

char **tmp = arg;
while (*tmp != NULL){
    free(*tmp); 
    tmp++;
}
free(arg);

Arrays aren't NULL terminated, that's only valid for strings (char * in C) — John, Oct 11 '15 at 13:02
you are in fact allocating memory for an array of char*, then allocating memory for each of items in the array. You have to free items first then free the array it self. — milevyo, Oct 11 '15 at 13:05
This is in fact not a bad idea, but you should explicitly put a `NULL` at the end of the array. I use this in many situations and it's good. — Iharob Al Asimi, Oct 11 '15 at 13:07
actually arg it is a dynamic array of char*; that can hold (argc) elements; elements are dynamic array of char that can hold (size) chars; each array and elements are freed separately; — milevyo, Oct 11 '15 at 15:29

Giorgi Moniava · Accepted Answer · 2015-10-11T13:18:47.427

3

No

while(*tmp != NULL){

you may reach above a point where you will dereference memory which hasn't been assigned to and trigger undefined behaviour.

Or as suggested you can explicitly assign a NULL to the last allocated pointer, and in that case it will work.

edited Oct 11 '15 at 13:18

answered Oct 11 '15 at 13:03

Giorgi Moniava

27,046
9
53
90

1

@lplouis: keep track how many pointers you have allocated memory to – Giorgi Moniava Oct 11 '15 at 13:06
so argc must not be forgotten? – Louis Kuang Oct 11 '15 at 13:06
2

@lplouis Alternatively, allocate `argc + 1` pointers and manually set the last one to `NULL`. – melpomene Oct 11 '15 at 13:08
And even though this can work if you add a `NULL` at the end, a much nicer way to do it would be `for (int i = 0 ; arg[i] != NULL ; ++i)` that way you don't need `tmp` – Iharob Al Asimi Oct 11 '15 at 13:10

score 0 · Answer 2 · answered Oct 11 '15 at 15:43

As others have said, the problems with freeing in a loop as shown is that an extra item (argc + 1) needs to be allocated and it has to be set to NULL. An alternative technique is to first allocate the space for the pointers as you have done

char **arg = malloc(sizeof(char*) * argc)

Then, if you know all the subsequent items are the same size, allocate it in one huge block and set the rest of the elements at spaced offsets

arg[0] = malloc(sizeof(char) * size * argc);
for (int i = 1; i < argc; ++i)
   arg[i] = arg[i - 1] + size;

Freeing the space is a doddle: no need to even remember argc

free(arg[0]); /* this will free the memory used by all the elements */
free(arg);

The big disadvantages to this technique is that if any of the array elements overrun, it will corrupt the next item. This cannot be detected so easily with a heap check unless it is the last item.

score -1 · Answer 3 · answered Oct 11 '15 at 13:14

if you define your char * array like this:

char **arg = calloc( 1, sizeof( char * ) * argc );

you can be sure that every undefined pointer will be equal to NULL

and then you can use the while loop almost like you suggested:

char *tmp = *arg;
while ( tmp != NULL ) {
    free( tmp ); 
    tmp++;
}
free(arg);

How to properly free char** in C

3 Answers3

Linked