Is valgrind not finding memory leaks? - c

Question

This code creates a BST, fills it, and makes an effort to release resources. Two versions of release() are shown below:
typedef struct Node {
int d;
struct Node *left;
struct Node *right;
} Node;
int main() {
Node **tree = NULL;
tree = mkTree();
if (!tree) {
puts("problem\n");
return 1;
}
insert(7, tree);
insert(3, tree);
insert(9, tree);
insert(6, tree);
printTree(*tree);
release(tree);
free(tree);
return 0;
}
/* Make a new binary tree */
Node **mkTree() {
Node **t = malloc(sizeof **t);
return t;
}
/* insert datum d into tree */
bool insert(int d, Node **tree) {
Node *newptr = NULL;
if (tree == NULL) { /*ptr to rootptr NULL */
return false;
}
if (*tree == NULL) {
newptr = buildNode(d);
if (!newptr) {
return false;
}
*tree = newptr;
return true;
}
return insert(d, d < (*tree)->d ? &(*tree)->left : &(*tree)->right);
}
What I don't understand is why valgrind claims all resources are freed in BOTH cases (I and II) below. I try to clear each node using release(), and, at the end of main, I call free(tree) to clear Node **tree, which is declared in main.
I.
/* release resources by passing Node **tree */
void release(Node **tree) {
if (*tree) {
Node *here = *tree;
release(&here->left);
release(&here->right);
}
free(*tree);
}
II.
/* passing Node *tree. this shouldn't free anything, right? */
void release(Node *tree) {
if (tree) {
Node *here = tree;
release(here->left);
release(here->right);
}
free(tree);
}
Despite the choice, running this program with four insertions gives
==5182== HEAP SUMMARY:
==5182== in use at exit: 0 bytes in 0 blocks
==5182== total heap usage: 5 allocs, 5 frees, 60 bytes allocated
What's happening here? Is valgrind just keeping a tally count of the number of malloc's and free's?

Answer 1

Both versions of Release are doing the same thing. One just has an extra (and unnecessary) level of indirection. You can pass a pointer to a function and free that pointer; it is not necessary to pass the address of the variable holding the pointer.
In fact, the call to free does exactly that. It just accepts the pointer value (not the address of the variable holding the pointer).