Freeing memory which has been allocated to an array of char pointers (strings). Do I have to free each string or just the "main" pointer?

I have a function that takes a pointer to a char ** and fills it with strings (an array of strings I guess). *list_of_strings* is allocated memory inside the function.

char * *list_of_strings = NULL;

/* list_of_strings malloc'd inside function */
fill_strings_with_stuff(&list_of strings);

use_list_for_something(list_of_strings);

/* Now how do I free it all? */

How would I go about freeing the memory after I've used the strings? If I call

free(list_of_s开发者_开发百科trings);

won't that just free the actual pointers and not the memory each string itself was using? How do I completely free the memory

Just for clarity the function looks something like this:

fill_strings_with_stuff(char *** list)
{
    *list = malloc(AMOUNT);

    for (i = 0; i < SOMETHING; i++) {
        *(list + i) = malloc(LINE_LEN);
        *(list + i) = some_string_from_somewhere
    }

    /* ... */

}

won't that just free the actual pointers and not the memory each string itself was using?

Yes, indeed.

How do I completely free the memory

By looping through the array and freeing each string one by one before freeing up the array itself. E.g.

for (i = 0; i < SOMETHING; i++) {
    free(list[i]);
}
free(list);

Basically, there's a rule of thumb to allocating and freeing: You need to call as many free() as you called malloc(). It's as simple as that. In every other case you got yourself a memory leak.

Yes, you have to free() every block you obtained from malloc(). You do it by traversing the array of pointers and caling free() on each element and only then freeing the array itself.

Only you know that there's a tree-like structure that could be freed recursively, that knowledge is not anywhere in the C runtime heap, so the heap manager has no idea about that and your program has to free everything itself.

You need to iterate over list and call free() on every array member. Then free the array.