Thread: assert(tree != NULL) doesnt fail

i moved the free(tree) call out of main and put it at the end of my destroy function. then in main added the assert but it doesn't fail. i ran valgrind --leak-check=full ./trunk and it says there is no memory leaks. i know its running on the latest version because of the data its spewing out to the screen

im just a little confused as to why the assert doesn't fail if the tree has actually been freed

ok thanks is that something i should be doing then?
coop

that doesn't fail either

Code:

void destroy(Bin_Tree *tree)
{
    Bin_Node *root = tree->root;

    destroy_tree(root);
    free(tree);
    tree = NULL;
}

i tried tree->root = NULL as well

so if it's local how am i freeing the real tree?

Originally Posted by cooper1200

that doesn't fail either

Code:

/* the argument 'tree' is LOCAL to the function. It is a COPY from the
   original pointer!!! */
void destroy(Bin_Tree *tree)
{
    Bin_Node *root = tree->root;

    destroy_tree(root);
    free(tree);
    tree = NULL;  // this will set the LOCAL 'tree' to NULL!
}

What you wanted to do:

Code:

void destroy(Bin_Tree **treepp)
{
    Bin_Node *root = (*treepp)->root;

    destroy_tree(root);
    free(*treepp);
    *treepp = NULL;
}

Get it?

i guess the answer to all this as main creates the variable *tree and then calls create tree it is reasonable for main to set the tree to null or of course implement flp's suggestion and send in &tree to destroy rather than tree.

@cooper1200,

You've just repeated the same lesson we've gone through on the manipulation of Bin_Tree's root inside your AVL code.

I think you have developed a belief that somehow a variable and the memory location returned by malloc are married into a kind of unified concept, but they're not.

To demonstrate:

Code:

Bin_Tree *t1 = malloc( sizeof( Bin_Tree ) );

Bin_Tree *t2 = t1;

Bin_Tree *t3 = t2;

All three, t1, t2, and t3 point to the same address given by malloc

Now

Code:

free( t3 );
t3 = null;

At this point, t3 is null and the memory is freed.

However, t1 and t2 still hold their pointer to that memory, even though the memory is freed, and if t1 and t2 use that pointer to see inside Bin_Tree, it will crash.

Another to drive this home....

Code:

Bin_Tree *t1 = malloc( sizeof( Bin_Tree ) );

destroy( t1 );

void destroy( Bin_Tree * t1 )
{
 free( t1 );
 t1 = NULL;
}

No matter what the name of the parameter in destroy, the memory is freed (as in the first example), but t1 is only set to NULL in the function. It is a copy of the pointer, so the caller of destroy still has a pointer to what malloc returned, but it still has been freed in destroy.

The only way a function can modify the parameter passed to it is with the idiom you've used for AVL tree insertion, like

Code:

Bin_Tree *t1 = malloc(.....);

destroy( &t1 ); /// the address of t1 is a pointer to a pointer of Bin_Tree



void destroy( Bin_Tree ** t1 )
{
 free( t1 );
 t1 = NULL;
}

@cooper1200,

Actually, @laserlight's question is a point within that question that is slightly more profound.

Due to the nature of the example code you're writing, you could actually use Bin_Tree on the stack. It is only Bin_Tree's root member that is dynamic.

Still, it IS dynamic, and something has to manage that, but Bin_Tree could be on the stack and all would work fine (automatic deletion of Bin_Tree), just not the Bin_Tree's root node. That would still be a clear of the tree.

However, in more "real" code (not an example), where Bin_Tree may mutate into a re-usable library, it would be rare that you could get away with that, and Bin_Tree would have to be dynamic as you're doing that now.

@laserlight, unless I misunderstand @cooper1200 from many threads he's started in AVL trees, I think he's studying to advance the code to a real, usable AVL tree, ultimately, where int may even be replaced with void *, and a pointer to a comparison function would eventually be required, so this tree would balance over hundreds or thousands of entries.

I am, however, making some assumption about that.

His larger, main code was already tested with up to 500 nodes, but not yet balanced by AVL