Why the allocation succeeds for size zero bytes?

This is similar to What does zero-sized array allocation do/mean?

I have following code

int *p = new int[0];
delete []p;

p gets an address and gets deleted properly.

My question is: Why allocation of zero bytes is allowed by c++ Standard in the first place? Why doesn't it throw bad_alloc or some special exception ?

I think, It is just postponing the catastrophic failure, making programmer's life difficult. Because if size to be allocated is calculated at run time and if programmer assumes its allocated properly and tries to write something to that memory, ends up corrupting memory !!! and Crash may happen some where else in the code.

EDI开发者_StackOverflow社区T: How much memory it allocates upon zero size request ?

Why would you want it to fail? If the programmer tries to read/write to non-existent elements, then that is an error. The initial allocation is not (this is no different to e.g. int *p = new int[1]; p[1] = 5;).

3.7.3.1/2:

[32. The intent is to have operator new() implementable by calling malloc() or calloc(), so the rules are substantially the same. C++ differs from C in requiring a zero request to return a non-null pointer.]

Compare dynamically allocated array to std::vector for example. You can have a vector of size 0, so why not allow the same for the array? And it is always an error to access past the end of the array whether its size is 0 or not.

Long time ago, before using exceptions, the malloc function returned a NULL pointer if the allocation failed.

If allocating zero bytes would also return a NULL pointer, it would be hard to make the distinction between a failed allocation and a succeeding-zero-bytes allocation.

On the other hand if the allocation of zero bytes would return a non-NULL pointer, you end up with a situation in which two different allocations of zero bytes can have the same pointer.

Therefore, to keep things simple, the malloc function of zero bytes allocates 1 byte.

The same can be said for int[N] where N>0:

Because if size to be allocated is calculated at run time and if programmer assumes its allocated properly and tries to write something past end of that memory, ends up corrupting memory !!! and Crash may happen some where else in the code.

Zero sized array allocation is covered in the ISO C++ Standard under 5.3.4, paragrahp 7

When the value of the expression in a direct-new-declarator is zero, the allocation function is called to allocate an array with no elements.

This makes code that performs dnaymic array allocation easier.

In general: If someone calls a function and asks it to return an array with n (0 in your case) elements, the code shouldn't be trying to read the returned array past the n-nth element anyway.

So, I don't really see the catastrophic failure, since the code would have been faulty to begin with for any n.

As you say:

Because if size to be allocated is calculated at run time and if programmer assumes its allocated properly

The calculated size would be "0", if he tries to access more than his calculated size then, well.. I am repeating myself ;)