C - Freeing pointers inside an array - c

Question

I've been trying to have all my pointers that I use malloc to initialize to be inside an array of pointers (or a pointer of pointers, perhaps), so that I can then just go through that array and free each pointer with something like free(ptr_array[i]); and not have to free each one individually.
I believe that this is possible, but I am having some trouble with my code, as the function that is supposed to free everything (and I would rather keep it all in a separate function, if possible) is apparently unable to properly edit the "sub-pointers", and seemingly they're being copied unlike the "main pointer".
Here's the code, which has me stumped:
#include <stdlib.h>
#include <stdio.h>
void free_test(int** arg){
printf("\tReceived arg addr: %p\n",arg);
printf("\tFreeing arg[0] = %p\n",arg[0]);
//And, just to MAKE SURE that arg[0] is ver, we do this:
printf("\tIn-function ver[0] = %d\n",arg[0][0]);
arg[0][0] = 2;
printf("\tIn-function ver[0] = %d\n",arg[0][0]);
free(arg[0]); //This one doesn't work...
free(arg); //This one works though.
}
int main(){
int** var;
int* ver;
int i;
printf("ver addr 1: %p\n", ver);
ver = malloc( sizeof(int) * 3 );
printf("ver addr 2: %p\n", ver);
for(i=0;i<3;i++){
ver[i] = 5*i;
}
for(i=0;i<3;i++){
printf("ver[%d]: %d\t(# %p)\n",i,ver[i],&(ver[i]));
}
printf("var addr 1: %p\n", var);
var = malloc( sizeof(int *) );
printf("var addr 2: %p\n", var);
var[0] = ver;
printf("var[0] addr = %p\n", var[0]);
free_test(var);
printf("ver[0] new value: %d\n", ver[0]);
//free(var); (free(arg) works in the function, so this one throws an error.)
printf("So far so good, now break.\n");
free(ver);
printf("Didn't break. :(\n");
return 0;
}
And this is the output it currently gives me:
ver addr 1: 0x8048679
ver addr 2: 0x8b0f008
ver[0]: 0 (# 0x8b0f008)
ver[1]: 5 (# 0x8b0f00c)
ver[2]: 10 (# 0x8b0f010)
var addr 1: 0xad7ff4
var addr 2: 0x8b0f018
var[0] addr = 0x8b0f008
Received arg addr: 0x8b0f018
Freeing arg[0] = 0x8b0f008
In-function ver[0] = 0
In-function ver[0] = 2
ver[0] new value: 0
So far so good, now break.
Didn't break. :(
I'm not too great with C, and thus any help would be appreciated. Specially since the value of ver[0] is altered inside the function, but not outside, and I'm guessing that will have to do with why free(...) doesn't work too.
Thanks in advance.

Answer 1

Well my knowledge of C is fading, but IIRC subsequent memory freeing causes undefined behaviour. Thus you are not guaranteed to recive any errors. If I understand it right the behaviour will be varying heavily depending on a particular OS, compiler and stdlib implementation (and even a particular program run).
P.S. My VS2012 VC++ compiler definetly breaks on free(ver);. The output is:
ver addr 1: CCCCCCCC
ver addr 2: 00B8AFF0
ver[0]: 0 (# 00B8AFF0)
ver[1]: 5 (# 00B8AFF4)
ver[2]: 10 (# 00B8AFF8)
var addr 1: CCCCCCCC
var addr 2: 00B85BF0
var[0] addr = 00B8AFF0
Received arg addr: 00B85BF0
Freeing arg[0] = 00B8AFF0
In-function ver[0] = 0
In-function ver[0] = 2
ver[0] new value: -17891602
So far so good, now break.

Answer 2

I have tested your code on gcc 4.6.3 and find that this program does not have any memory leaks using valgrind. And when I delete the line "free(ver)" in main, the program runs perfectly and does not have any memory leak either. I think free_test routine has successfully freed those two malloc you have in main. As for why there is not any coredump pops out when freeing the var again in the program, it depends on different OS implementation.
Test it with valgrind and you will find it useful if you want to check memory leaks involving malloc and free.

Answer 3

Use
"* (*(arg+0)+0)"
instead of [][].
Syntax like [][]...[] only dereference pointer once. Each [] only change the semantic of pointer (how many location it jumps when +1), have nothing to do with dereference times.
void free_test(int** arg){
printf("\tReceived arg addr: %p\n",arg);
printf("\tFreeing arg[0] = %p\n",arg[0]);
//And, just to MAKE SURE that arg[0] is ver, we do this:
printf("\tIn-function ver[0] = %d\n",arg[0][0]);
arg[0][0] = 2;
// ^^^^^^^^^^^^^^ here, arg[0][0] is the same as arg[0], so arg[0] is changed, not the location arg[0] points to.
printf("\tIn-function ver[0] = %d\n",arg[0][0]);
free(arg[0]); //This one doesn't work...
free(arg); //This one works though.
}

Answer 4

Why this comment in your code?
free(arg[0]); //This one doesn't work...
I think it did work, and it freed the data var points to, and then you freed it again.
Your debug data shows
ver addr 2: 00B8AFF0
Freeing arg[0] = 00B8AFF0
If you comment out the first time you freed it, it still fails?
and you used it after freeing it the first time:
printf("ver[0] new value: %d\n", ver[0]); /// but you already freed that
Try using
void *xmalloc(int s) {
char *ret = malloc(s);
printf("malloc(%d)==%p\n", s, ret);
return ret;
}
void xfree(void *b) {
printf("free(%p)\n", b);
free(b)
return;
}
#define malloc xmalloc
#define free xfree
It's been a long time since I worked in C.
Initialize your variables.
int** var = NULL;
int* ver = NULL;
Before you free a block of data, set it to all zeros (or some other value).
memset(void_ptr, 0, sizeof_your_data);
It's a LOT easier to read your code if you delete all those print statements... though I know they are useful for debugging... try it (make a backup first).