On Saturday 23 February 2008, Chris ク Heath wrote:

On Fri, 2008-02-22 at 11:15 +0100, Michael Kerrisk wrote:

quoted

On Thu, Feb 21, 2008 at 7:59 AM, Mike Frysinger [off-list ref] wrote:

quoted

On Thursday 21 February 2008, Lasse Kärkkäinen wrote:
 > The man page says that realloc(ptr, 0) is equivalent to free, even
 > though it isn't. The text on the man page says
 >
 > ---
 > realloc()  changes the size of the memory block pointed to by ptr to
 > size bytes.  The contents will be unchanged to the minimum of the
 > old and new sizes;  newly  allocated memory  will  be 
 > uninitialized.   If ptr  is  NULL,  the call is equivalent to
 > malloc(size); if size is equal to zero, the call is equivalent to
 > free(ptr).  Unless ptr is NULL, it must have been returned by an
 > earlier call to malloc(), calloc() or realloc().  If the area
 > pointed to was moved, a free(ptr) is done. [...]
 > realloc()  returns a pointer to the newly allocated memory, which is
 > suitably aligned for any kind of variable and may be different from
 > ptr, or NULL if the request fails.  If  size  was equal to 0, either
 > NULL or a pointer suitable to be passed to free() is returned.  If
 > realloc() fails the original block is left untouched; it is not
 > freed or moved.

 i would just word it to say that when realloc() is given a size of 0,
it is implementation defined as to the behavior, but it tends to match
the behavior of malloc(0) (which too is implementation defined).  POSIX
and C99 allow both cases to return either a NULL pointer or a "unique"
pointer.  glibc will return a unique pointer (which cannot actually be
used to store anything), but uClibc may return NULL.
 -mike

Lasse, thanks for raising this; Mike, thanks for your input.

For man-pages-2.79, I propose to amend the description of realloc() to
be:

       realloc() changes the size of the memory block pointed to
       by  ptr to size bytes.  The contents will be unchanged to
       the minimum of the old and  new  sizes;  newly  allocated
       memory  will  be uninitialized.  If ptr is NULL, then the
       call is equivalent to malloc(size); if size is  equal  to
       zero, and ptr is not NULL, then the call is equivalent to
       free(ptr).   Unless  ptr  is  NULL,  it  must  have  been
       returned  by  an  earlier  call  to malloc(), calloc() or
       realloc().  If the area pointed to was moved, a free(ptr)
       is done.

Hmmm.  The phrase

                                           if size is  equal  to
       zero, and ptr is not NULL, then the call is equivalent to
       free(ptr).

seems to contradict the following sentence, found under RETURN VALUES:

                              If size was equal to 0, either NULL
        or a pointer suitable to be passed to free() is returned.

If realloc(ptr, 0) can return a non-NULL pointer, then it isn't
equivalent to free(ptr).

So which one is correct?  My tests with glibc 2.6 indicate that
realloc(ptr, 0) always returns NULL, so it IS equivalent to free(ptr).
However, I don't know if that is guaranteed to always be the case.

this isnt a question that can be answered here.  you would have to ask for 
clarification on the open group mailing list as they are the ones who 
maintain the POSIX documentation.

for the purposes of the man page, i think this can be ignored.  or replace the 
sentence "the call is equivalent to free(ptr)" with "the ptr is freed".
-mike