Почему там новое специальное предложение, и удалите для массивов?

Различие - это delete только удалит весь диапазон памяти, но только назовет деструктор для 1 объекта. delete[] и удалит память и назовет деструктор для каждого объекта. Если Вы не используете delete[] для массивов это - только вопрос времени, прежде чем Вы введете утечку ресурсов в свое приложение.

Обновление РЕДАКТИРОВАНИЯ

Согласно стандарту, передавая объект, выделенный с new[] кому: delete не определено. Вероятное поведение состоит в том, что это будет действовать, как я описал.

Stroustrup говорит о причинах отдельного new/new[] и delete/удалите []' операторы в "Дизайне и Эволюции C++" в разделах 10.3 до 10.5.1:

• 10.3 Распределение массива - обсуждает это, они хотели способ позволить массивам объектов быть выделенными с помощью отдельной схемы от отдельных объектов выделения (т.е., выделяя массивы от отдельного хранилища). Добавление версий массива new и delete было решение для этого;
• 10.5.1 Освобождение Массивов - обсуждает как проблема с освобождением массивов, использующих просто сингл delete оператор - то, что должно быть больше информации, чем просто указатель, чтобы определить, указывает ли указатель на первый элемент массива или если это просто указывает на отдельный объект. Вместо того, чтобы "усложнить общий падеж выделения и освобождения отдельных объектов", delete[] оператор используется для обработки массивов. Это согласуется с общей философией дизайна C++, "не платят за то, что Вы не используете".

Было ли это решение ошибкой или не спорно - так или иначе имеет хорошие аргументы, но мы имеем то, что мы имеем.

Относительно, "почему" в заголовке: одна из целей дизайна C++ была то, что не будет никаких скрытых затрат. C++ был также разработан в то время, когда каждый байт памяти все еще имел значение намного больше, чем это делает сегодня. Разработчики языка также как ортогональность: если Вы выделяете память с new[] (вместо new), необходимо освободить его с delete[].

Я не думаю, что существует любая техническая причина это new[] не мог засунуть флаг "I am an array" в заголовок блока памяти для delete (не больше delete[]) посмотреть на позже.

new и delete отличаются от malloc и free в этом malloc и free только выделите и свободная память; они не называют ctors или dtors.

Причина этого требования является исторической и потому что new type и new type [size] возвратите разные вещи, которые должны быть очищены по-другому.

Рассмотрите этот код

Foo* oneEntry = new Foo;
Foo* tenEntries = new Foo[10];

Они оба возвращают Нечто* указатель, различием является второй вызов, приведет к конструктору Foo, вызываемому 10x, и там являющийся примерно 10x столько же памяти.

Таким образом, теперь Вы хотите освободить свои объекты.

Для отдельного объекта Вы звонили бы, удаляют - например. delete oneEntry. Это называет деструктор объектов и и освобождает память.

Но вот проблема - oneEntry, и аренда является оба просто указателями Foo. Компилятор понятия не имеет, указывают ли они на один, десять, или тысяча элементов.

Когда Вы используете специальный синтаксис delete []. Это говорит компилятору, что "это - массив объектов, выясните количество и затем разрушьте их всех".

То, что действительно происходит, является этим для new type [size] компилятор тайно хранит 'размер' где-то в другом месте. Когда Вы звоните, удаляют [], это знает, что это секретное значение существует так, это может узнать, сколько объектов находится в том блоке памяти и разрушает их.

Вопрос, который Вы могли затем задать, "почему компилятор не всегда хранит размер?"

Это - большой вопрос, и он относится ко времени первых лет C++. Было требование, что для встроенных типов (символ, интервал, плавание, и т.д.) следующее будет допустимо для C++;

int* ptr = new int;
free(ptr);

int* ptr = (int*)malloc(sizeof(int) * someSize);
delete ptr;

Обоснование позади этого было ожиданием, что люди обеспечат библиотеки, которые возвратили динамично выделенную память, и у пользователей этих библиотек не будет способа знать, использовать ли, освобождают/удаляют.

Это требование совместимости означало, что размер массива не мог быть сохранен как часть самого массива и должен был быть сохранен в другом месте. Из-за этих издержек (и помнят, это вернулось в начале 80-х), было решено сделать эту бухгалтерию только для массивов и не единственных элементов. Таким образом потребность массивов, специальное предложение удаляет синтаксис, который ищет это значение.

Причина malloc/free не имеет этой проблемы, то, что они просто имеют дело с блоками памяти и не должны волноваться о звонящих конструкторах/деструкторах.

Когда Вы используете new[] для выделения массива Вы на самом деле говорите C++ размер массива. Когда Вы используете malloc, Вы вместо этого говорите это, сколько памяти выделяется. В бывшем случае, освобождающем на основе размера массива, не имел бы смысла. В этом случае это делает. Но с тех пор нет никакого различия между указателем для массива по сравнению с для отдельного объекта, отдельная функция необходима.