Possible Duplicate:
Setting variable to NULL after free …
I am learning about good C programming practices and my friend told me to always set the pointers to NULL after free()ing them (or calling a specific freeing function).
For example:
char* ptr = malloc(100);
...
free(ptr);
ptr = NULL;
or
struct graph* graph = create_graph();
...
destroy_graph(graph);
graph = NULL;
Why is this a good practice?
Update: After reading the answers, it seems an awful practice to me! I am hiding possible double-free() errors. How can this possibly be a good practice? I am shocked.
Thanks, Boda Cydo.
After using free(ptr) , it's always advisable to nullify the pointer variable by declaring again to NULL. e.g.: free(ptr); ptr = NULL; If not re-declared to NULL, the pointer variable still keeps on pointing to the same address (0x1000), this pointer variable is called a dangling pointer.
It is always a good practice to assign the pointer NULL to a pointer variable in case you do not have exact address to be assigned. This is done at the time of variable declaration. A pointer that is assigned NULL is called a null pointer.
Yes, when you use a free(px); call, it frees the memory that was malloc'd earlier and pointed to by px. The pointer itself, however, will continue to exist and will still have the same address.
While it can't hurt, it doesn't always help. The issue to consider is that it's easy for there to be multiple copies of the pointer and most likely you are only going to set a single one to NULL. The classic example of where it doesn't help at all is:
void free_graph(graph *g)
{
...
free(g);
g = NULL; // not useful in this context
}
The problem here is that you are only setting the pointer that is local to free_graph
to NULL and the pointer is held by the caller of free_graph
will still have it's original value.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With