Почему [] используется в delete (delete []) для освобождения динамически выделенного массива?

основная причина, почему было решено держать отдельно delete и delete[] заключается в том, что эти две сущности не так похожи, как может показаться на первый взгляд. Для наивного наблюдателя они могут показаться почти одинаковыми: просто разрушаются и освобождаются, с единственной разницей в потенциальном количестве обрабатываемых объектов. На самом деле разница гораздо более существенна.

самое важное различие между этими двумя является то, что delete может выполнять полиморфное удаление объектов, т. е. статический тип объекта может отличаться от его динамического типа. delete[] С другой стороны должны заниматься строго запрещено-полиморфное удаление массивов. Таким образом, внутренне эти две сущности реализуют логику, которая существенно отличается и не пересекается между ними. Из-за возможности полиморфного удаления, функциональность delete даже отдаленно не совпадает с функциональностью delete[] на массив из 1 элемента, как наивный наблюдатель мог бы ошибочно предположить.

вопреки странным утверждениям, сделанным в некоторых других ответах, это, конечно, вполне возможно заменить delete и delete[] только с одной конструкцией, которая будет ветвиться на самой ранней стадии, т. е. она определит тип блока памяти (массив или нет), используя информацию о домохозяйстве, которая будет храниться new/new[], а затем перейти к соответствующей функциональностью, эквивалентной либо delete или delete[]. Однако это было бы довольно плохое дизайнерское решение, так как, опять же, функциональность двух слишком отличается. Принудить обоих к одной конструкции было бы сродни созданию швейцарского армейского ножа с функцией освобождения. Кроме того, чтобы иметь возможность отличить массив от не-массива, нам пришлось бы ввести дополнительную часть бытовой информации даже в однообъектные выделения памяти, выполненные с помощью plain new. Это может легко привести к заметным память в один распределении объектов.

но, еще раз, основная причина здесь-функциональная разница между delete и delete[]. Эти языковые сущности обладают лишь кажущимся поверхностным сходством, которое существует только на уровне наивной спецификации ("деструкт и свободная память"), но как только человек понимает в деталях, что эти сущности действительно должны делать, он понимает, что они слишком разные, чтобы быть объединены в одно.

P. S. Это кстати одна проблем с предложением о sizeof(type) вы сделали в вопрос. Из-за потенциально полиморфной природы delete, вы не знаете тип в delete, поэтому вы не можете получить любой sizeof(type). С этой идеей больше проблем, но этого уже достаточно, чтобы объяснить, почему она не будет летать.

куча сама знает размер выделенного блока - вам нужен только адрес. Похоже, free () работает - вы только передаете адрес, и он освобождает память.

разницу между delete (delete[]) и free() это то, что первые два сначала вызывают деструкторы, а затем свободную память (возможно, используя free()). Проблема в том, что delete[] также имеет только один аргумент-адрес и, имея только этот адрес, он должен знать количество объектов для запуска деструкторов. Так new[] использует реализацию som-определенный способ записи где - то количества элементов-обычно он добавляет массив с количеством элементов. Теперь delete[] будет полагаться на эти данные реализации для запуска деструкторов, а затем свободной памяти (опять же, только с использованием адреса блока).

delete[] просто вызывает другую реализацию (функцию);

нет причин для распределителя не мог отслеживать его (в самом деле, было бы достаточно легко написать свой собственный).

Я не знаю, почему им это не удалось, или историю реализации, если бы я догадался: многие из них " ну, почему это не было немного проще?"вопросы (на C++) сводились к одному или нескольким из:

1. совместимость с C
2. производительность

в этом случае, производительность. Используя delete vs delete[] достаточно просто, я считаю, что все это может быть абстрагировано от программиста и быть достаточно быстрым (для общего использования). delete[] требуется только несколько дополнительных вызовов функций и операций (исключая вызовы деструктора), но это за вызов delete, и ненужный, потому что программист обычно знает тип, с которым он / она имеет дело (если нет, скорее всего, большая проблема под рукой). Поэтому он просто избегает вызова через распределитель. Кроме того, эти одиночные распределения, возможно, не должны отслеживаться распределителем так подробно; обработка каждого распределения как массива потребует дополнительных записей для подсчета для тривиальных распределений, поэтому это несколько уровней простых упрощений реализации распределителя, которые на самом деле важны для многих людей, учитывая, что это очень низкоуровневый домен.

Это сложнее.

ключевое слово и соглашение об использовании его для удаления массива были изобретены для удобства реализаций, и некоторые реализации используют его (я не знаю, какой. MS VC++ не делает).

удобство заключается в следующем:

во всех остальных случаях, вы знаете точный размер, чтобы быть освобождены другими средствами. Когда вы удаляете один объект, вы можете иметь размер из sizeof () времени компиляции. При удалении полиморфного объект по базовому указателю и у вас есть виртуальный деструктор, вы можете иметь размер как отдельную запись в vtbl. Если вы удалите массив, как вы узнаете размер освобождаемой памяти, если вы не отслеживаете ее отдельно?

специальный синтаксис позволит отслеживать такой размер только для массива - например, помещая его перед адресом, который возвращается пользователю. Это требует дополнительных ресурсов и не требуется для не-массивы.