How do I free an entire array whose elements have been individually allocated memory via calls to malloc/calloc

Question

From what I know, malloc and calloc are just book keeping APIs on underlying memory. Keeping this in mind, I wonder if a call to free() will free up an entire array whose individual elements have been allocated memory through independent calls to malloc (or calloc).

Precisely, I have the following code:

int *num,* num_start;

num_start=num;

for(i=0;i<N;i++)
{
    num = (int *)calloc(0, sizeof(int));
    num++;
}

free(num_start);

Will free(num_start) free up the entire array of N integer elements which have been dynamically allocated space, independently?

Answer 1

The "code" you posted does not make any sense and is wrong.

int *num, num_start;
num_start=num;

num_start is an integer not pointer.

for(i=0;i<N;i++)
{
    num = (int *)calloc(0, sizeof(int));
    num++;
}

to be honest I do not understand what what this code is supposed to do, but for sure is wrong

if you want to allocate memory for N integers

int *num = calloc(N, sizeof(*num));

and to free you only need

free(num);

Or if you want to allocate pointer to store N pointers to N integers

int **allocate(size_t N)
{
    int **num = malloc(N * sizeof(*num));
    for(size_t i=0; i<N; i++)
    {
        num[i] = calloc(N, sizeof(**num));
    }
    return num;
}

void arrayfree(int **num, size_t size)
{
    for(size_t i = 0; i < size; i++)
    {
        free(num[i]);
    }
    free(num);
}

When you allocate memory you have to check if the operation was successful. Those checks are not included in the example to make the code easier to read.

Answer 2

The calloc() and malloc() functions return a pointer to the allocation which doubles as a handle to release that memory. While you're free to make copies of that pointer and manipulate those as you see fit, when you call to free() you must provide the original value.

That is to say this does work:

// Original allocation
int* x = calloc(42, sizeof(int));

// Making a new (independent) copy of the pointer to a new pointer
int* p = x;

// Arbitrary pointer manipulation and mangling
x++;

// Freeing with the copied value
free(p);

You can also get a bit adventurous, so long as you return to your original destination:

int* x = calloc(42, sizeof(int));

x += 40;
x -= 30;
x += 10;
x -= 13;
x -= 7;

free(x);

Where here x has returned to its original value after a short journey. In general practice it's better to preserve the original pointer than to have to reconstruct it later. Make copies if you're intending to manipulate them.