<p>This is a question that's been nagging me for some time. I always thought that C++ should have been designed so that the <code>delete</code> operator (without brackets) works even with the <code>new[]</code> operator.</p>

<p>In my opinion, writing this:</p>

<pre><code>int* p = new int;
</code></pre>

<p>should be equivalent to allocating an array of 1 element:</p>

<pre><code>int* p = new int[1];
</code></pre>

<p>If this was true, the <code>delete</code> operator could always be deleting arrays, and we wouldn't need the <code>delete[]</code> operator.</p>

<p>Is there any reason why the <code>delete[]</code> operator was introduced in C++?  The only reason I can think of is that allocating arrays has a small memory footprint (you have to store the array size somewhere), so that distinguishing <code>delete</code> vs <code>delete[]</code> was a small memory optimization.</p>

It's so that the destructors of the individual elements will be called.  Yes, for arrays of PODs, there isn't much of a difference, but in C++, you can have arrays of objects with non-trivial destructors.
Now, your question is, why not make
```
new
```
and
```
delete
```
behave like
```
new[]
```
and
```
delete[]
```
and get rid of
```
new[]
```
and
```
delete[]
```
?  I would go back Stroustrup's "Design and Evolution" book where he said that if you don't use C++ features, you shouldn't have to pay for them (at run time at least).  The way it stands now, a
```
new
```
or
```
delete
```
will behave as efficiently as
```
malloc
```
and
```
free
```
.  If
```
delete
```
had the
```
delete[]
```
meaning, there would be some extra overhead at run time (as James Curran pointed out).