delete[] mechanics

[ninja9578]

Don't have to call destructors on primitives.

char * array = new char[5];
delete[] array;

No dtors.

Also, you don't need to know the number of elements to call of the destructors. You can easily determine that by total_allocated_space / sizeof(element). In fact, the iterating is probably done by using a running pointer, not an index anyway. My guess is that most compilers record the size of the space, not the number of items, because in the end, new[]/delete[] uses malloc / free. free doesn't care how many items is in it, just how many bytes.

[ProgrammerC++]

You're right, my example shows if there's no destructor, then the number of elements is not stored at all, because it is not needed anyway.

What you say about total_allocated_space etc is correct, but I guess it's faster for the run-time to store the number of elements like the way I said, than to ask the heap handler for the size of the space given a pointer...

Plus there's no such thing as

int GetSizeOfSpace( void * ptr );

[ninja9578]

Plus there's no such thing as

int GetSizeOfSpace( void * ptr );

I never said that there was. But the compiler and/or operating system knows how much space is allocated by ptr.

An int can't tell you how much space anyway, ints aren't big enough is most casts, and a size would certainly be unsigned :P

[ProgrammerC++]

Yes the compiler know how much space is allocated, that's why the number of elements is stored, but only when an array of a class is allocated of which the class has a destructor, else it won't because it's never needed anyway.

The OS ofcourse knows how much bytes is allocated for a specific pointer, but I guess it's faster for the run-time to store the number of elements this way than to ask the OS how much bytes the size of space is for a specific pointer

[ninja9578]

Now I'm curious. Put this into your compiler:

DWORD * array = new DWORD[0x1FFFFFFFFUL];
std::cout << array[-1] << std::endl;

If I remember correctly, DWORD is only 32 bits, what happens if you go outside of it's range?


Also, don't be so sure that the compiler knows how much space is allocated, it might be asking a runtime library or something.

[VladimirF]

Yes the compiler know how much space is allocated, that's why the number of elements is stored,

You think that compiler stores that number?
Try this modified version of your code:

int _tmain(int argc, _TCHAR* argv[])
{
	cout << sizeof( ABC ) << endl;

	ABC * arr = new ABC[argc];