Question

It’s bothering me what delete [] actually does, so I just tried some code and I was shocked with the results

Test #1:

int main()
{
    int *d;
    while(true)
    {
        d = new int[10];
        delete []d;
    }
}

The program doesn’t consume any memory at all, as expected.

Test #2:

int main()
{
    int *d;
    while(true)
    {
        d = new int[10];
        delete [](d + 5);
    }
}

Though in every loop there should be at least 20 bytes (for the five ints it reserves at the beginning of array) reserved which are not deleted this program also doesn’t consume any memory!

Test #3:

int main()
{
    int *d;
    while(true)
    {
        d = new int[10];
        delete []d;
        *d=1;
    }
}

This one caused access violation as expected (seems all the memory is deleted after delete []d).

Test #4:

int main()
{
    int *d;
    while(true)
    {
        d = new int[10];
        delete [](d+5);
        *d=1;
    }
}

This one was the most amazing, though the while doesn’t consume any memory the program doesn’t produce any access violations either, I’m just wondering where *d is storing it’s data?

(By the way all programs are compiled using no-optimization!)

Now the main question :

What if I allocated an array and I’ve done working with half of it, can’t I by any chance release that half and keep the other half?

Answer 1

it’s bothering me what delete []
actually does

You’re not supposed to worry about what delete[] actually does. It’s for all intents and purposes a black box with certain rules on how to use it properly. The only time you need to worry about what it needs to actually do is if you’re writing a compiler or a C++ runtime (e.g. operating systems, etc.)

With respect to those “certain rules on how to use it properly”, Test #2 and #4 invokes undefined behavior:

ISO C++ 2003 Standard 5.3.5 Delete [expr.delete]

1 The delete-expression operator destroys a most derived object (1.8) or array created by a new-expression.

    delete-expression:
        ::opt delete cast-expression
        ::opt delete [ ] cast-expression

The first alternative is for non-array
objects, and the second is for arrays.
The operand shall have a pointer type,
or a class type having a single
conversion function (12.3.2) to a
pointer type. The result has type
void.

2 If the operand has a class type, the
operand is converted to a pointer type
by calling the above-mentioned
conversion function, and the converted
operand is used in place of the
original operand for the remainder of
this section. In either alternative,
if the value of the operand of delete
is the null pointer the operation has
no effect. In the first alternative
(delete object), the value of the
operand of delete shall be a pointer
to a non-array object or a pointer to
a sub-object (1.8) representing a base
class of such an object (clause 10).
If not, the behavior is undefined.
In the second alternative (delete array), the value of the operand of
delete shall be the pointer value
which resulted from a previous array
new-expression. If not, the
behavior is undefined. [Note: this
means that the syntax of the
delete-expression must match the type
of the object allocated by new, not
the syntax of the new-expression. ]

“Undefined Behavior” means that anything can happen, including the behavior you just described.

These expressions that you have in Tests #2 and #4 are in violation of 5.3.5/2 and will cause undefined behavior (Test #3 will also cause undefined behavior, but for a different reason).

d = new int[10];
delete [](d + 5);

The delete[] line violates 5.3.5/2 because pointer value you pass to delete[] wasn’t the same value that was given to you from new int[].

So if the new int[] command gives you 0xA01D2CE9 and you pass in 0xA01D2CE9 + 5 to delete[], you cannot possibly reason about or predict what will happen because you have broken the rules of the language. What will actually happen will be dependent on how the compiler and/or the operating system handles new[] and delete[]. That can range from nothing wrong happening to completely crashing your system, and everywhere in between.

In other words, just don’t write things like delete [](d + 5);.