Question

I am wondering about the delete[] operator in C++. (I am using Visual Studio 2005).

I have an unmanaged DLL that is being called by a managed DLL. When I close this program after performing a few tasks while debugging, I am getting many (thousands?) of memory leaks, mostly 24 bytes – 44 bytes in size.. I suspect it might be due to a certain unmanaged DLL I have.

Anyway, from what I understand, if I have the following code:

char* pointer = new char[500]
/* some operations... */
delete[] pointer;

Then all the memory for it is freed up correctly, am I right?

What happens when I have the following code:

char* pointer = new char[500];
char* pointerIt = pointer;
/* some code perhaps to iterate over the whole memory block, like so */
for (int i = 0; i < 250; i++){ // only iterate halfway
    *pointerIt = 0;
    pointerIt++;
}

delete[] pointer;

The memory pointed to by pointer is deleted right? So it means that pointerIt is now not pointing to valid memory.. But that’s ok because I can set both pointers to NULL, right?

Anyway, what happens now if I do this:

char* pointerFirstPosition = new char[500];
char* pointerIt = pointerFirstPosition;

for (int i = 0; i < 250; i++){ // only iterate halfway
    *pointerIt = 0;
    pointerIt++;
}

delete[] pointerIt; // delete the pointer iterator...

Will this code delete the memory block pointed to by pointerIt up to pointerIt +500? or will it delete the memory block pointed to by pointerFirstPos to pointerFirstPos +500?

Could this result in a memory leak?

Sorry for the long winded message, I’m trying to get my message across clearly.

Thanks,

kreb

Answer 1

First question set:

char* pointer = new char[500] 
/* some operations... */ 
delete[] pointer;

Then all the memory for it is freed up
correctly, am I right?

right.

Second question set:

char* pointer = new char[500];
char* pointerIt = pointer;
/* some code perhaps to iterate over the whole memory block, like so */
for (int i = 0; i < 250; i++){ // only iterate halfway
    *pointerIt = 0;
    pointerIt++;
}

delete[] pointer;

The memory pointed to by pointer is
deleted right? So it means that
pointerIt is now not pointing to valid
memory.. But that’s ok because I can
set both pointers to NULL, right?

The memory pointer holds an address to is fully delted yes. Both pointer and pointerIt hold an address to invalid memory. Each pointer is simply a variable, and every variable is independent. So both store their own address independent of each other. The dereference operator * will simply give you the variable at that address. The variable at that address is a different variable than the pointer variable.

Third question set:

You should be deleting only the address that was allocated, the whole array. You’ll have undefined results if you try to delete a partial array. Could it result in a memory leak? Possibly, could it result in a crash? Possibly, could it result in ….? Possibly.

So only delete what you allocate. If you allocate an array then you delete with delete[] if you delete a type that is not an array you delete with delete.

Here is an eample of something that is fine just for clarity:

char* pointer = new char[500];
char* pointerIt = pointer;
//This is fine because you are deleting the same address:
delete[] pointerIt;
//The memory that both variables point to is freed, do not try to free again