Почему синтаксис delete [] существует в C ++?

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

Чтобы иметь только одну версию, реализации потребуется механизм для отслеживания дополнительной информации о каждом указателе. Но один из основополагающих принципов C ++ заключается в том, что пользователя не следует заставлять оплачивать затраты, которые ему совершенно не нужны.

Всегда delete то, что вы new и всегда delete[] то, что new[]. Но в современном C ++ new и new[] обычно больше не используются. Используйте std::make_unique, _ 10_, _ 11_ или другие более выразительные и безопасные альтернативы.

Обычно malloc и free выделяют память, а new и delete создают и уничтожают объекты. Итак, вы должны знать, что это за объекты.

Чтобы подробнее рассказать о неуказанных накладных расходах, упомянутых в ответе Франсуа Андриё, вы можете увидеть мой ответ на этот вопрос, в котором я изучил, что делает конкретная реализация делать (Visual C ++ 2013, 32-бит). Другие реализации могут делать то же самое, а могут и не делать.

В случае, если new[] использовался с массивом объектов с нетривиальным деструктором, он выделял на 4 байта больше и возвращал указатель, сдвинутый на 4 байта вперед, поэтому, когда delete[] хочет знать, сколько там объектов, он берет указатель, сдвигает его на 4 байта раньше, берет число по этому адресу и обрабатывает его как количество сохраненных там объектов. Затем он вызывает деструктор для каждого объекта (размер объекта известен из типа переданного указателя). Затем, чтобы освободить точный адрес, он передает адрес, который был на 4 байта раньше переданного адреса.

В этой реализации передача массива, выделенного с помощью new[], в обычный delete приводит к вызову единственного деструктора первого элемента с последующей передачей неправильного адреса функции освобождения памяти, что приводит к повреждению кучи. Не делай этого!

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

Они имеют примитивную семантику C и не имеют семантики C ++, и, следовательно, компилятор C ++ и поддержка времени выполнения, что позволит вам или системам времени выполнения компилятора делать полезные вещи с указателями на них.

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

Эта бородавка на языке C ++ возникла из-за наследия C. И он остается частью языка - даже несмотря на то, что теперь у нас есть std::array для массивов фиксированной длины и (всегда было) std::vector для массивов переменной длины - в основном для целей совместимость: возможность обращаться с C ++ к API операционной системы и к библиотекам, написанным на других языках, с использованием взаимодействия с языком C.

И ... потому что существует масса книг, веб-сайтов и классов, обучающих массивам очень рано в своей педагогике на C ++, из-за а) способности рано писать полезные / интересные примеры, которые на самом деле действительно вызывать API ОС, и, конечно же, из-за потрясающей силы b) мы всегда так поступали.

Как правило, компиляторы C ++ и связанные с ними среды выполнения строятся поверх среды выполнения C платформы. В частности, в этом случае диспетчер памяти C.

Диспетчер памяти C позволяет вам освобождать блок памяти, не зная его размера, но нет стандартного способа получить размер блока из среды выполнения, и нет гарантии, что фактически выделенный блок имеет именно тот размер, который вы просил. Вполне может быть больше.

Таким образом, размер блока, хранящийся в диспетчере памяти C, нельзя использовать для обеспечения функциональности более высокого уровня. Если функциональным возможностям более высокого уровня требуется информация о размере распределения, они должны хранить ее сами. (И C ++ delete[] действительно нуждается в этом для типов с деструкторами, чтобы запускать их для каждого элемента.)

C ++ также придерживается позиции, согласно которой вы платите только за то, что используете, хранение поля дополнительной длины для каждого выделения (отдельно от бухгалтерии базового распределителя) не соответствовало бы такой позиции.

Поскольку обычным способом представления массива неизвестного (во время компиляции) размера в C и C ++ является указатель на его первый элемент, компилятор не может отличить выделение одного объекта от выделения массива на основе типа. система. Так что возможность различать остается на усмотрение программиста.

Прикрытие состоит в том, что delete требуется из-за связи C ++ с C.

Оператор new может создать динамически выделяемый объект практически любого типа объекта.

Но из-за наследия C указатель на тип объекта неоднозначен между двумя абстракциями:

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

Ситуация delete против delete[] просто следует из этого.

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

Вот неофициальное доказательство. Вызов оператора new T (случай одного объекта) мог неявно вести себя так, как если бы он был new T[1]. То есть каждый new всегда может выделить массив. Когда не упоминается синтаксис массива, может подразумеваться, что будет выделен массив из [1]. Тогда просто должна была бы существовать одна delete, которая ведет себя как сегодняшняя delete[].

Почему не соблюдается этот дизайн?

Думаю, все сводится к обычному: это коза, принесенная в жертву богам эффективности. Когда вы выделяете массив с помощью new [], для метаданных выделяется дополнительная память, чтобы отслеживать количество элементов, так что delete [] может знать, сколько элементов необходимо повторить для уничтожения. Когда вы выделяете один объект с помощью new, такие метаданные не требуются. Объект может быть построен непосредственно в памяти, которая поступает из нижележащего распределителя без какого-либо дополнительного заголовка.

Это часть не платить за то, что вы не используете, с точки зрения затрат времени выполнения. Если вы выделяете отдельные объекты, вам не нужно оплачивать какие-либо накладные расходы на представление в этих объектах, чтобы иметь дело с возможностью того, что любой динамический объект, на который ссылается указатель, может быть массивом. Однако на вас возложена ответственность за кодирование этой информации так, как вы выделяете объект в массиве new и впоследствии удаляете его.

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

Вот пример:

#include <iostream>
#include <stdlib.h>
#include <string>

using std::cerr;
using std::cout;
using std::endl;

class silly_string : private std::string {
  public:
    silly_string(const char* const s) :
      std::string(s) {}
    ~silly_string() {
      cout.flush();
      cerr << "Deleting \"" << *this << "\"."
           << endl;
      // The destructor of the base class is now implicitly invoked.
    }

  friend std::ostream& operator<< ( std::ostream&, const silly_string& );
};

std::ostream& operator<< ( std::ostream& out, const silly_string& s )
{
  return out << static_cast<const std::string>(s);
}

int main()
{
  constexpr size_t nwords = 2;
  silly_string *const words = new silly_string[nwords]{
    "hello,",
    "world!" };

  cout << words[0] << ' '
       << words[1] << '\n';

  delete[] words;

  return EXIT_SUCCESS;
}

Эта тестовая программа явно инструментирует вызовы деструктора. Очевидно, это надуманный пример. Во-первых, программе не нужно освобождать память непосредственно перед завершением работы и освобождением всех своих ресурсов. Но он демонстрирует, что происходит и в каком порядке.

Некоторые компиляторы, такие как clang++, достаточно умны, чтобы предупредить вас, если вы оставите [] в delete[] words;, но если вы все равно заставите его скомпилировать ошибочный код, вы получите повреждение кучи.

Delete - это оператор, который уничтожает объекты массива и объекты, не являющиеся массивом (указателем), которые генерируются новым выражением.

Его можно использовать либо с помощью оператора Delete, либо с помощью оператора Delete []. Новый оператор используется для динамического распределения памяти, который помещает переменные в динамическую память. Это означает, что оператор Delete освобождает память из кучи. Указатель на объект не уничтожается, значение или блок памяти, на который указывает указатель, уничтожается. Оператор удаления имеет тип возвращаемого значения void, который не возвращает значения.