Question

int main( )    
{
    int *p;
    p=(int *)malloc(20);
    printf("%u",p); \\ printing some memory adress 
    p=(int *)realloc(p,0);
    printf("%u",p); \\ printing as 0
    printf("%u",*p); \\ printing the value as 0
}

Now my question is the statement relloc working as the free() function as the pointer p is pointing to the NULL and NULL value in it. Will that 20 bytes be freed?

Answer 1

No, it may not be freed in all circumstances. C99 has this to say in 7.20.3.4 The realloc function:

If memory for the new object cannot be allocated, the old object is not deallocated and its value is unchanged.

Now you may think that an allocation of zero bytes couldn’t possibly fail but the standard doesn’t mandate that. It says, for zero-sized objects:

If the size of the space requested is zero, the behaviour is implementation defined: either a null pointer is returned, or the behaviour is as if the size were some non-zero value, except that the returned pointer shall not be used to access an object.

So, if your implementation is one of those that doesn’t return NULL for a zero-size allocation, and it requires some housekeeping information for each allocation, and the memory arena is so full that you can’t store even another housekeeping header, and it’s not smart enough just to split the current allocation and return most of it to the arena, it may fail a zero-size realloc and hence not free the original memory.

Now this is a (very) edge case depending on a lot of decisions made in the implementation, most of which may seem bizarre to people with experience of writing them. Unfortunately, we have to allow for the edge cases as well 🙂

If it really worries you, I’d just change:

p=(int *)realloc(p,0);

into:

free (p) ; p = NULL;

---

A couple of other points.

1. Comment marjers are forward slashes /, not backslashes.
2. You are not allowed to dereference p in that final line whether or not your implementation returns NULL for a zero-size allocation. See my second quote above where it states: “except that the returned pointer shall not be used to access an object”.
3. You shouldn’t really cast the return values from malloc-type calls. This is a hangover from the dim dark past before C had a void*, and malloc returned char*. The problem with doing so nowadays is, if you forget to include stdlib.h, problems can be hidden from you.