You already got plenty of answers. Think of it this way: the c++
new/new[] delete/delete[] "API", so to speak, is a pointer.
The pointer itself is just abstraction of concept called "memory
address", the delete does see only a pointer. It must implement a flag
to tell if the "memory" that was being allocated previously with new is
array or not, for it to be able to handle freeing memory allocated with
new and new[] both alike. Such flag or similiar construct does not
exist, so the burden of knowing if memory was allocated with new or
new[] falls to the application.
This code...
char* buffer = new char[100000];
delete buffer;
... invokes undefined behaviour. Most likely it will even compile into
*identical* platform specific binary code. But it doesn't have to. The
code may just aswell explode your PC, or turn your poop green for a
week, or place a Viagra order.
The situation is even more volatile (not that it makes any difference)
if the type is not char, but some class with very complex memory
management scheme. Let's say, you allocate 100 objects with new[], then
you "free" the memory using delete. The destructor for these objects
isn't called and that may be a problem (but again, that is not relevant
as you already invoken undefined behaviour and ANYTHING can go wrong).
Example:
Your compiler and platform implements delete differently from delete[]
-- they are completely independent the delete[] is NOT implemented in a
way that it first calls destructors for the array objects and then uses
delete (plain) to free the memory, instead, the implementation of
delete does read from data associated with delete[], which has totally
different memory layout. It reads a variable from wrong address from
memory, let's assume that this doesn't yet crash and the address has
literal value of 12. Let's further assume that this code runs on x86
architechture on ring0 privilege level, then let's assume that we write
into this address (physical address, not linear address) and we
overwrite interrupt table entry there. Then this interrupt is
controlling some gadget attached to the PC, and this gadget gets a
wrong signal and overheats, then a curtain is hanging over the gadget,
it catches fire, then your house burns down and the Taleban terrorists
next door also have their hideout on fire. Then their improvised dirty
bomb (WMD!!!) explodes destroying three square miles of neighbourhood
and contaminating 20,000 people of whom 8,000 die of cancer in the next
10 years. You survive the undefined behaviour, but lose your balls.
Or, the code might *appear* to work without any ill side effects
whatsoever. You never know.
