Thread: Question on free()

I come from a C++ background where 'delete' was different if you're working with an array of memory. With free(), does it delete the array automatically?

Code:

#include <stdio.h>
#include <stdlib.h>   
#include <string.h>  
#include "actor.h"
#include "stack.h" 

int main(void)
{         
	ASTACK stkActors;    
	ACTOR PC, PC2, PC3;
	ACTOR actTemp;

	/* Initialize the actors */
	Actor_Init(&PC, "Bob", 1);
	Actor_Init(&PC2, "Bobby", 2);
	Actor_Init(&PC3, "Other Bob", 3); 

	/* Initialize the dynamic stack of 32 actors */
	AStack_Init(&stkActors, 32);

	/* Push actors into the stack. */
	AStack_Push(&stkActors, &PC);
	AStack_Push(&stkActors, &PC2);
	AStack_Push(&stkActors, &PC3);

	/* Pop away! */
	AStack_Pop(&stkActors, &actTemp);
	Actor_Show(&actTemp);

	AStack_Pop(&stkActors, &actTemp);
	Actor_Show(&actTemp);

	AStack_Pop(&stkActors, &actTemp);
	Actor_Show(&actTemp); 

	/* Release the stack memory */
	AStack_Release(&stkActors);
 
	return 0;
}

(Just showing the code because it's beautiful).

Actually, on AStack_Release(&stkActors), I call free() this way:

Code:

void AStack_Release(ASTACK *s)
{
	if (s->p_stck != NULL)
		free(s->p_stck);
	
	s->p_stck = NULL;
}

Is that right? And I heard free() implicitly checks for null so the condition isn't necessary. Is this correct? Thanks.

PS. Just a side note, how's this C coding style above that I developed for C coding? I think OO helped me to be clear more like myStructureType_DoSomething(&myStructure, ...).

free(NULL) is benign and works on every compiler that I know of.

On the other hand, your code may leak depending on what Actor_Init does. If it allocates memory dynamically for an ACTOR, then doing free on the stack's array isn't enough: You'll need to traverse the whole stack and deallocate the resources for each ACTOR.

Originally Posted by Kennedy

Define p_stck -- there's not enough information.

YES. Always check for NULL before you call free().

No, Don't. free(NULL) is well-defined by the standard to do nothing.

From the C89 standard draft:

...
The free function causes the space pointed to by ptr to be
deallocated, that is, made available for further allocation. If ptr
is a null pointer, no action occurs. Otherwise, if the argument does
not match a pointer earlier returned by the calloc , malloc , or
realloc function, or if the space has been deallocated by a call to
free or realloc , the behavior is undefined."

Originally Posted by zacs7

No, Don't. free(NULL) is well-defined by the standard to do nothing.

It's also one of those areas where the implementations commonly get it wrong.

Originally Posted by brewbuck

It's also one of those areas where the implementations commonly get it wrong.

I have heard of this assertion, but how true is it these days, some twenty years after the C standard was first published? After all, getting the code right in itself should not be difficult, but knowing that the behaviour is supposed to be that may be another matter, but it should now be well known.

Some ancient pre-ANSI C compilers (especially embedded ones) may have had trouble freeing NULL.
I also recall some PoC that didn't even do short-circuit && || evaluation properly.

You would never get anywhere if you "coded around" every real (or imagined) bug in any compiler. If a compiler fails on this basic stuff, raise bug reports or shop around for something better.