( POD )freeing memory : is delete equal to delete ?
delete deallocate the elements beyond the first in an array?
char *s = new char[n];
Does it matter in the above case seeing as all the elements of
s are allocated contiguously, and it shouldn't be possible to
delete only a portion of the array?
For more complex types, would
delete call the destructor of objects beyond the first one?
Object *p = new Object[n];
delete deduce the number of
Objects beyond the first, wouldn't this mean it must know the size of the allocated memory region? What if the memory region was allocated with some overhang for performance reasons? For example one could assume that not all allocators would provide a granularity of a single byte. Then any particular allocation could exceed the required size for each element by a whole element or more.
For primitive types, such as
int, is there any difference between:
int *p = new int[n];
Except for the routes taken by the respective calls through the
free deallocation machinery?
It's undefined behaviour (most likely will corrupt heap or crash the program immediately) and you should never do it. Only free memory with a primitive corresponding to the one used to allocate that memory.
Violating this rule may lead to proper functioning by coincidence, but the program can break once anything is changed - the compiler, the runtime, the compiler settings. You should never rely on such proper functioning and expect it.
delete uses compiler-specific service data for determining the number of elements. Usually a bigger block is allocated when
new is called, the number is stored at the beginning and the caller is given the address behind the stored number. Anyway
delete relies on the block being allocated by
new, not anything else. If you pair anything except
delete or vice versa you run into undefined behaviour.