What happens if I re-alloc and the new size is 0. Is this equivalent with a free ?

Question

Given the following code:

int *a = NULL;
a = calloc(1, sizeof(*a));
printf("%d\n", a);
a = realloc(a, 0);

printf("%d\n", a);
return (0);

It returns:

4078904
0

Is this realloc equivalent to a free ?

NOTE: I am using MinGW under WindowsXP.

Answer 1

http://www.cplusplus.com/reference/clibrary/cstdlib/realloc/ says yes.

Answer 2

Not necessarily.

It often does as with the link that munissor posted, but the Mac OS 10.5 man page says:

If size is zero and ptr is not NULL, a new, minimum sized object is allocated and the original object is freed.

What is a "minimum sized object"? Well, any allocator stores some information about the allocations, and that takes space which is often allotted in addition to the space reserved for the user. Presumably a "minimum sized object" is just one of these headers plus zero bytes of space reserved for the user.

I would guess that this provision is present to support implementations that existed at the time of standardization, and that those implementations are useful for debugging allocation behavior.

---

To address Jonathan's comments

Consider the difference between

for (int i=0; i<VERY_BIG_NUMBER; ++i){
  char *p = malloc(sizeof(char[10]));
  free(p);
}

and

for (int i=0; i<VERY_BIG_NUMBER; ++i){
  char *p = malloc(sizeof(char[10]));
  realloc(p,0);
}

With a sane implementation of malloc and free the first clip does not consume memory without bound. But if the realloc implementation returns those "minimum sized objects" it might.

Certainly this example is contrived and it relies on understanding what is meant by "minimum sized object", but I think that text allows it.

In short, if you mean free you should say free.

Answer 3

It may or may not be equivalent to calling free on the pointer; the result is implementation-defined.

From the C99 standard (§7.20.3/1):

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

That applies to all of the memory management functions, including realloc.

Answer 4

Yes

The C99 standard §7.20.3.4 (realloc) says:

The realloc function deallocates the old object pointed to by ptr and returns a pointer to a new object that has the size specified by size. The contents of the new object shall be the same as that of the old object prior to deallocation, up to the lesser of the new and old sizes. Any bytes in the new object beyond the size of the old object have indeterminate values.

If ptr is a null pointer, the realloc function behaves like the malloc function for the specified size. Otherwise, if ptr 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 the free or realloc function, the behavior is undefined. If memory for the new object cannot be allocated, the old object is not deallocated and its value is unchanged.

This clearly states that the old object is deallocated (freed). The return value might be a null pointer, or it might be a value as specified in the general notes for §7.20.3:

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

Either way, you cannot dereference the value returned: it could be used as an argument to free(), or passed to other functions as long as they in turn do not reference it.