Can I use `operator delete[]` for a single element array allocation?

Question

If we allocate an object of size 1 as below

int *arr = new int[1];

Should we delete the object using operator delete[] or operator delete?

The reason I am concerned is if the compiler would be smart enough to convert the statement as a single element allocation int *arr = new int which would cause calling operator delete[] UB.

User Case:

I have a pointer, which I would end up allocation in a varied ways but would finally like to get it deleted. So was wondering, for single element allocation, if I consistently use int *arr = new int[1] can I consistently and safely use operator delete[]

Note

Can you please refer me back to the standards to support your answer?

Answer 1

You must use delete[] and not delete. The compiler is not allowed to change new int[1] to new int.

(As int is a POD type it's quite possible that new int and new int[1] do exactly the same thing under the covers, but if this is the case then delete[] on and int* and delete on an int* will also do exactly the same thing.)

ISO/IEC 14882:2011 5.3.5 [expr.delete] / 2:

In the first alternative (delete object), the value of the operand of delete may be a null pointer value, a pointer to a non-array object created by a previous new-expression, or a pointer to a subobject (1.8) representing a base class of such an object (Clause 10). If not, the behavior is undefined.

As int[1] is an array object, if you try and delete it with delete and not delete[], the behavior is undefined.

Answer 2

The rule is quite simple:

1. always balance a new with a delete
2. always balance a new[] with a delete[]

otherwise you get undefined behaviour.

There are no exceptions; even new[1] must be balanced with a delete[], and new[0] must be deleted as the compiler can still reserve storage.

Answer 3

Should we delete the object using operator delete[] or operator delete?

operator delete[]. You have allocated an array of ints, so there's no other option for correctly deallocating it. Using operator delete would invoke undefined behavior.

Answer 4

You must use delete[].

C++11 5.3.5 Delete

::opt delete cast-expression

::opt delete [ ] cast-expression

The first alternative is for non-array objects, and the second is for arrays.

An array holding one element is still an array.

Answer 5

int *arr = new int[1];

Since you use [] for allocation, you need to use [] for deleteas well.

Memory leaks

The objects created by new expressions (objects with dynamic storage duration) persist until the pointer returned by the new expression is used in a matching delete-expression.

So you should use delete[] for releasing the memory or else you get undefined behaviour.

And _(incase), if the complier is smart enough to take int * arr = new int[1] as int, It must be smart enough to take delete[] arr on arr as delete arr. However, there is nothing for delete to differentiate between the arr from int*arr = new int[1] and int*arr = new int. The [] in delete is going to indicate it.

Answer 6

No its not safe, it may leads to some unwanted situations.
For example,It is possible in a memory to have some data (int/char/float...) next to the location where your pointer points to. At that time if you used delete [] then it may try to delete that data too if it is an integer,for other data types it leads to unexpected errors.

Example:

int *ptr = new int;
int a = 20;
char c = 'e';
*ptr = 10;
delete [] ptr;

There is a possibility the c and a variables may store next to the location where the pointer ptr points to, If a is stored next to it, then it deletes "a" also, if the other data types are present, leads to unexpected runtime results.

So it's advised to use delete[] only for the deletion of memory allocated using new datatype[].Hope this is useful.