How to properly free malloced variable passed into variadic function? - c

Question

Consider the following example
char** make_copy(int argc, char** argv){
char** new_argv = malloc((argc+1) * sizeof *new_argv);
for(int i = 0; i < argc; ++i)
{
size_t length = strlen(argv[i])+1;
new_argv[i] = malloc(length);
memcpy(new_argv[i], argv[i], length);
}
new_argv[argc] = NULL;
return new_argv;
}
Above function malloc memory to make copies
void free_space(**args, ...){
// how to do ?
}
int main(){
char** string1 = make_copy(); # make a copy of some string
char** string2 = make_copy(); # make a copy of another string
char** string3 = make_copy(); # make a copy of third string
free_space(string1, string2, string3, NULL);
}
without make any assumption of number of passing variable, what is the most efficient way of freeing malloced space?

Answer 1

A macro can send a dummy first parameter and a final NULL, then just use a va_list inside your function:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#define free_all(...) free_all(0, __VA_ARGS__, NULL)
void (free_all)(int dummy, ...)
{
va_list args;
va_start(args, dummy);
while (1)
{
char **ptr = va_arg(args, char **);
if (ptr == NULL)
{
break;
}
while (*ptr != NULL)
{
free(*ptr);
ptr++;
}
}
va_end(args);
}
int main(void)
{
char *a[] = {strdup("abc"), strdup("123"), NULL};
char *b[] = {strdup("bcd"), strdup("456"), NULL};
char *c[] = {strdup("cde"), strdup("789"), NULL};
free_all(a, b, c);
}
or if your prefer you can pass a compound literal to a function expecting an array of pointers (with the advantage that the compiler can do type checking):
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void free_all(char **list[])
{
while (*list != NULL)
{
char **ptr = *list;
while (*ptr != NULL)
{
free(*ptr);
ptr++;
}
list++;
}
}
int main(void)
{
char *a[] = {strdup("abc"), strdup("123"), NULL};
char *b[] = {strdup("bcd"), strdup("456"), NULL};
char *c[] = {strdup("cde"), strdup("789"), NULL};
free_all((char **[]){a, b, c, NULL});
return 0;
}
if you want to hide the construction of the compound literal at the cost of obfuscating the code with a macro:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define free_all(...) free_all(((char **[]){__VA_ARGS__, NULL}))
void (free_all)(char **list[])
{
while (*list != NULL)
{
char **ptr = *list;
while (*ptr != NULL)
{
free(*ptr);
ptr++;
}
list++;
}
}
int main(void)
{
char *a[] = {strdup("abc"), strdup("123"), NULL};
char *b[] = {strdup("bcd"), strdup("456"), NULL};
char *c[] = {strdup("cde"), strdup("789"), NULL};
free_all(a, b, c);
return 0;
}

Answer 2

What you want is to use a sentinel value to mark the end of the variable arguments list:
void free_one(void *ptr) {
// logic to free a pointer
}
void free_all(void *ptr, ...) {
// short-circuit free_all(NULL)
if (!ptr) return;
va_list args;
free_one(ptr);
va_start(args, ptr);
while (true) {
void *arg = va_arg(args, void *);
// stop on the first NULL
if (!arg) break;
free_one(arg);
}
va_end(args);
}
Usage:
free_all(NULL); // no-op
free_all(string1, string2, string2, NULL);
The only caveat is that you can't pass a NULL pointer this way, since NULL denotes the end of the variable arguments list. So:
free_all(string1, NULL, string2);
Will not free string2.

Answer 3

You have to iterate over arguments and free them one by one. I would do just:
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
char** make_copy(int argc, char** argv) {
char** new_argv = malloc((argc + 1) * sizeof *new_argv);
for (int i = 0; i < argc; ++i) {
size_t length = strlen(argv[i]) + 1;
new_argv[i] = malloc(length);
memcpy(new_argv[i], argv[i], length);
}
new_argv[argc] = NULL;
return new_argv;
}
void free_one(char** ptr) {
for (char** i = ptr; *i; ++i) {
free(*i);
}
free(ptr);
}
void free_space(char** ptr, ...) {
va_list va;
va_start(va, ptr);
while (ptr) {
free_one(ptr);
ptr = va_arg(va, char**);
}
va_end(va);
}
int main() {
char** string1 = make_copy(1, (char*[]){"1a"});
char** string2 = make_copy(2, (char*[]){"2a", "2b"});
char** string3 = make_copy(3, (char*[]){"3a", "3b", "3c"});
free_space(string1, string2, string3, NULL);
}