Is there any harm in calling 'free' for the same pointer twice in a C program?

Question

If I have a c program, like:

SomeTypePtr my_type;
my_type = malloc(sizeof(someType));

/* do stuff */

free(my_type);

/* do a bunch of more stuff */

free(my_type);

Does the calling of 'free' for my_type do any harm? After I call free(my_type), does the pointer become a null pointer once again?

Undressed

See en.wikipedia.org/wiki/Malloc#Use_after_free – Columbous

Answer 1

Deallocating a memory area with free does not make the contents of the pointer NULL. Suppose that you have int *a = malloc (sizeof (int)) and a has 0xdeadbeef and you execute free (a) then after execution a still contains 0xdeadbeef but after the free call this memory address is no more reserved for you. Something like you have rented a flat with malloc used for some time, returned the flat by free then you might have a duplicate key for the flat, but it is not reserved for you.

Doing a free on an already freed memory will result in double free memory corruption.

Alberic

oh, that's very clear, thankyou. Is there a way to detect if the memory for a pointer has bee deallocated? – Undressed

I guess this is why I have see some best practice documents sugerst that you should always manually set your pointers to = NULL after you call free(pointer). – Undressed

@Ash: have a look at this post: #4143882 – Alberic

Definitely you should assign unused pointer with a NULL. This will help you identify which one is unused with if - else – Alberic

@phoxis: I disagree: this will prevent you from realizing that a pointer has been free'd multiple times, which is almost always a bug. – Voltage

depends on what you are implementing. If you are implementing a linked list, then assigning the last pointer to NULL would be best. And for determining for multiple free, yes that is also a point. – Alberic

Answer 2

1. It will not make your pointer NULL.
2. It will free the memory pointed by the pointer, leaving the pointer set to an unallocated segment of memory.
3. If you don't use malloc or calloc between the calls it will give you a Segmentation Fault.
4. "Best practice is that a pointer passes out of scope immediately after being freed." means that the pointer should stay on the stack so that it should not be set NULL explicitly because it will eventually go out of scope and be freed.

Haruspex

It will give a SEGV if you are lucky. :) – Taro

Answer 3

Only if you consider destroying your heap "harm". free() will not make your pointer null.

Telegonus

So, how can I test to see if a pointer has been properly freed? – Undressed

The call will always be successful, unless there's nothing to be freed , in which case it will casue a Segmentation Fault. – Haruspex

The wikipedia article I linked has a fairly terse but wise answer to this: "Best practice is that a pointer passes out of scope immediately after being freed." – Columbous

Answer 4

Without repeating the other answers, it is incumbent on you to null pointers once you have called free(). Calling free() twice on the same allocation will result in heap corruption.

SomeTypePtr my_type;
my_type = malloc(sizeof(someType));

/* do stuff */

free(my_type);
my_type = 0; // Throw away the pointer to released memory, so cannot either free it or use it in any way.

/* do a bunch of more stuff */

free(my_type); // OK now - calling free(0) is safe.

Plumb