Why does malloc(0) return a non-null address in Windows?

Question

The code below returns an address when executed in Windows, though I was expecting it to return NULL.

int main()
{
   char *ptr = NULL;
   ptr = malloc(0);
   printf("malloc returned = %u\n", ptr);

}

What could have prompted such an implementation of malloc? Is there any reason behind it?

Since, this is a 0 byte memory, I didn't experiment writing any data. But, can this memory be used for anything at all?

Answer 1

It's just the minimum size you're requesting. And since there are no zero-length blocks in the Win32 heap, you can:

void *p = malloc(0);
// ... do some stuff in between...
realloc(p, n);

Which should mostly result in reusing a block of the heap (if you're lucky and the new size is small). A minor opportunist optimization (or a slow-down, depending on the context and blood coffee-levels).

This is a simplified example. The actual situation could be a class that allocates a buffer when it's created and also allows to grow it. If the inputs are annoying to control, you could just let it do that zero-sized buffer allocation.

Answer 2

To answer the second part of your question no, the memory can't be used for anything, since "the accessible part of it" is 0 bytes starting from the address returned.

IIRC it is guaranteed though that if the implementation does return non-null, then it will be a different address from any other currently allocated memory block. So in theory you could use the address as a temporary unique ID (of pointer type), although obviously there are plenty of other ways of getting a unique ID. And even if you were going to use it for that, malloc(1) would work just as well as malloc(0) and be more portable.

Answer 3

That's answered within the comp.lang.c FAQ: http://c-faq.com/ansi/malloc0.html

The ANSI/ISO Standard says that it may do either; the behavior is implementation-defined (see question 11.33). Portable code must either take care not to call malloc(0), or be prepared for the possibility of a null return.