Блог

Меня беспокоит то, что delete [] на самом деле делает, поэтому я просто попробовал некоторый код и был шокирован результатами

Тест # 1:

 int main()
{
    int *d;
    while(true)
    {
        d = new int[10];
        delete []d;
    }
}
  

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

Тест # 2:

 int main()
{
    int *d;
    while(true)
    {
        d = new int[10];
        delete [](d   5);
    }
}
  

Хотя в каждом цикле должно быть зарезервировано не менее 20 байт (для пяти целых чисел, которые он резервирует в начале массива), которые не удаляются, эта программа также не потребляет никакой памяти!

Тест # 3:

 int main()
{
    int *d;
    while(true)
    {
        d = new int[10];
        delete []d;
        *d=1;
    }
}
  

Это вызвало нарушение доступа, как и ожидалось (кажется, вся память удалена после delete []d ).

Тест # 4:

 int main()
{
    int *d;
    while(true)
    {
        d = new int[10];
        delete [](d 5);
        *d=1;
    }
}
  

Эта была самой удивительной, хотя, хотя она не потребляет никакой памяти, программа также не создает никаких нарушений доступа, мне просто интересно, где * d хранит свои данные?

(Кстати, все программы скомпилированы без оптимизации!)

Теперь главный вопрос :

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

меня беспокоит, что delete [] на самом деле делает

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

Что касается этих «определенных правил о том, как правильно это использовать», тесты # 2 и # 4 вызывают неопределенное поведение:

Стандарт ISO C 2003 5.3.5 Удалить [expr.delete]

1 Оператор delete-expression уничтожает наиболее производный объект (1.8) или массив, созданный новым выражением.

     delete-expression:
        ::opt delete cast-expression
        ::opt delete [ ] cast-expression
  

Первая альтернатива — для не-массива
объекты, а второй — для массивов.
Операнд должен иметь тип указателя,
или тип класса, имеющий один
функция преобразования (12.3.2) в
тип указателя. Результат имеет тип
пустота.

2 Если операнд имеет тип класса, операнд преобразуется в тип указателя путем вызова вышеупомянутой функции преобразования, и преобразованный операнд используется вместо исходного операнда в оставшейся части этого раздела. В любом варианте, если значением операнда delete является нулевой указатель, операция не имеет эффекта. В первой альтернативе (удалить объект) значением операнда delete должен быть указатель на объект, не являющийся массивом, или указатель на подобъект (1.8), представляющий базовый класс такого объекта (пункт 10). Если нет, то поведение не определено. Во второй альтернативе (удалить массив) значением операнда delete должно быть значение указателя, полученное в результате предыдущего нового выражения массива. Если нет, то поведение не определено. [Примечание: это означает, что синтаксис выражения удаления должен соответствовать типу объекта, выделенного с помощью new, а не синтаксису нового выражения. ]

«Неопределенное поведение» означает, что может произойти что угодно, включая поведение, которое вы только что описали.

Эти выражения, которые у вас есть в тестах # 2 и # 4, нарушают 5.3.5 / 2 и приведут к неопределенному поведению (тест # 3 также вызовет неопределенное поведение, но по другой причине).

 d = new int[10];
delete [](d   5);
  

delete[] Строка нарушает 5.3.5 / 2, потому что значение указателя, которое вы передаете delete[] , не совпадает с тем значением, которое было передано вам из new int[] .

Итак, если new int[] команда выдает вам 0xA01D2CE9 , и вы переходите в 0xA01D2CE9 5 to delete[] , вы не можете рассуждать или предсказать, что произойдет, потому что вы нарушили правила языка. То, что на самом деле произойдет, будет зависеть от того, как компилятор и / или операционная система обрабатывает new[] и delete[] . Это может варьироваться от того, что ничего плохого не происходит, до полного сбоя вашей системы, и везде между ними.

Другими словами, просто не пишите такие вещи, как delete [](d 5); .

Когда вы говорите «не потребляет никакой памяти», вы имеете в виду просмотр внутри монитора производительности в стиле «диспетчер задач»? Потому что, если это так, 40 байт не будут отображаться как «использование памяти» … вам придется выделить намного больше памяти, чтобы это отображалось в большинстве стандартных мониторов производительности процесса.

 delete [](d   5);
  

(из вашего теста № 2) — это определенно то, чего вам не следует делать, это приведет к повреждению памяти, если не к segfault. На моей платформе это действительно приводит к сбоям.

Результат ваших тестов будет зависеть от многих факторов, среди прочего, от платформы, на которой вы запускаете эти тесты, от внутренних компонентов new/delete и т.д.

 delete [](d   5);
  

Похоже, вы ожидаете, что это освободит только часть памяти, выделенной new int[10] .

Это не тот случай, это вызывает неопределенное поведение и может привести к тому, что произойдет что угодно.

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

Другое соображение заключается в том, что new int[10] не инициализирует выделенную память, поэтому операционная система может просто выделить некоторое адресное пространство и не нуждается в резервном выделении с помощью какого-либо физического хранилища. Это означает, что даже если вы вызываете new int[10] в цикле без какого-либо delete[] , вы можете не заметить увеличения использования памяти во многих инструментах мониторинга памяти, вплоть до того момента, когда new[] выдается std::bad_alloc исключение при исчерпании адресного пространства logicalbvg. (Вероятно, это займет некоторое время, просто выделяя 10 байт за раз.)

Вы запускаете эти тесты в рамках выпуска сборки? Вы просмотрели сгенерированные инструкции по сборке? Как вы измеряете потребление памяти? Вы просто выделяете 40 байт, а затем немедленно очищаете их.

Кроме того, выполнение чего-то подобного delete [](d 5) вызывает неопределенное поведение. Вам нужно передать указатель, возвращаемый operator new для delete корректной работы.