Почему в С++ массивы нужно удалять через delete[]
Заметка рассчитана на начинающих C++ программистов, которым стало интересно, почему везде твердят, что нужно использовать delete[] для массивов, но вместо внятного объяснения – просто прикрываются магическим «undefined behavior». Немного кода, несколько картинок и взгляд под капот компиляторов – всех заинтересованных прошу под кат.
Введение
Может быть, вы не замечали, или даже просто не обращали внимания, но, когда вы пишете код для освобождения памяти, занятой массивами, то вам не приходится писать количество элементов, которые нужно удалить. При этом всё замечательно работает.
Это что, магия? Отчасти – да. Причём разработчики различных компиляторов видят и реализуют её по-разному.
Существует два основных подхода к тому, как компиляторы запоминают количество элементов в массиве:
- Запись количества элементов перед самим массивом («Over-Allocation»)
- Хранение количества элементов в обособленном ассоциативном контейнере («Associative Array»)
Over-Allocation
Первый способ, как понятно из названия, реализуется простой записью количества элементов перед массивом. Обратите внимание, что в таком случае указатель, который вы получите после выполнения оператора new, будет указывать на первый элемент массива, а не на его фактическое начало.
Такой указатель ни в коем случае нельзя передавать обычному оператору delete. Скорее всего, он просто удалит первый элемент массива, а остальные оставит нетронутыми. Заметьте, я не просто так написал «скорее всего» – ведь никто не может гарантировать, что произойдёт на самом деле и как дальше будет вести себя ваша программа. Всё зависит от того, какие объекты находились в массиве и делали ли они что-то важное в своих деструкторах. То есть получаем классическое неопределённое поведение. Согласитесь, это не то, чего вы ожидаете при попытке удалить массив.
Чем же отличается оператор delete[]? А он как раз считывает количество элементов в массиве, вызывает деструктор для каждого объекта и уже после этого очищает память (вместе со скрытой переменной).
Если кому будет интересно, то примерно в такой псевдокод превращается конструкция delete[] p; при использовании этой стратегии:
Этим способом пользуются компиляторы MSVC, GCC и Clang. В этом можно убедиться, взглянув на код работы с памятью в соответствующих репозиториях (GCC и Clang) или воспользовавшись сервисом Compiler Explorer.
Как видно на изображении выше (верхняя часть – код, нижняя – ассемблерный вывод компилятора), я набросал простенький код, в котором объявлена структура и функция для создания массива этих самых структур.
Что же происходит с точки зрения ассемблера простым языком:
- cтрока N3: запись требуемого количества памяти (20 байт на 5 объектов + 8 байт на размер массива) в регистр;
- cтрока N4: вызов оператора new для выделения памяти;
- cтрока N5: запись количества элементов в начало выделенной памяти;
- cтрока N6: смещение указателя на начало массива на sizeof(size_t), полученный результат является возвращаемым значением.
К достоинствам этого способа можно отнести его лёгкость в реализации и скорость работы, ну а к недостаткам – то, что он не прощает ошибок с некорректным выбором оператора delete. В лучшем случае – сразу получите падение программы с ошибкой «Heap Corrupt», а в худшем – будете долго и мучительно искать причины странного поведения программы.
Associative Array
Второй способ подразумевает существование скрытого глобального контейнера, в котором хранятся указатели на массивы и сколько элементов они содержат. В таком случае перед массивами нет никаких скрытых данных, а вызов delete[] p; реализуется примерно вот так:
Что ж, выглядит не так «магически», как прошлый вариант. Есть ли ещё какие различия? Да.
Кроме уже упомянутого отсутствия скрытых данных перед массивом, мы получаем небольшое замедление работы из-за необходимости поиска данных в глобальном хранилище. Но компенсируем это тем, что программа может более снисходительно относиться к неверному выбору оператора delete.
Данный подход использовался в компиляторе Cfront. Останавливаться на его реализации мы не будем, но если кому интересно покопаться во внутренностях одного из первых C++ компиляторов, то сделать это можно на GitHub.
Мини-послесловие
Всё вышеописанное является внутренней кухней компиляторов, и полагаться на то или иное поведение не стоит. Особенно это касается случаев, когда планируется портирование программы на разные платформы. Благо что есть несколько вариантов как можно избежать данного класса ошибок:
- Использовать семейства функций std::make_*. Например: std::make_unique, std::make_shared.
- Использовать средства статического анализа для раннего выявления ошибок, например PVS-Studio. ��
Если же вас заинтересовала тема неопределённого поведения и особенностей работы компиляторов, то могу посоветовать ещё парочку дополнительных материалов:
Оператор delete: удаление массива
Везде где читал, сказано что массив нужно удалять вторым способом.
Если вы выделяли память при помощи new[] , вы обязаны освободить её с помощью delete[] . Так гласит стандарт.
Освобождение такой памяти как-то по-другому ( delete без [] или вообще free ) является Undefined Behaviour. Если в программе есть Undefined Behaviour, она имеет право вести себя как угодно: может ничего плохого не делать, может вылететь в любой точке, отформатировать ваш винчестер или выбросить из окна вашего кота.
You have been warned.
Если Вы выделили массив элементов, то этот массив и нужно удалить. New делает malloc на sizeof(объект) и вызывает конструктор объекта, new[] делает malloc на sizeof(объект) * кол-во_объектов, вызывает конструкторы для каждого будущего объекта и записывает информацию о том, память для скольких объектов была выделена. Куда и как эта информация записывается вопрос отдельный (плюс бывает ситуации когда это информация не нужна).
Вызывая delete Вы говорите компилятору «удали этот один элемент по такому-то адресу». Оператор delete[] же читает сколько объектов расположено в выделенной памяти (как мы помним, оператор new[] сохранил это число в процессе своей работы), вызывает для каждого их них деструктор, а после вызывает free() , «отдавая память назад ОС». Именно поэтому для памяти, выделенной через new/new[] нужно вызывать delete/delete[] соответственно. Контроль за тем, что для оператора выделения должен быть вызван соответствующий оператор освобождения лежит на программисте.
Удалить массив в C++
Программирование и разработка
Массив относится к группе компонентов, имеющих одинаковые типы данных, расположенных в ячейках встроенной памяти. На него можно ссылаться исключительно через индекс к одному идентификатору. Вы можете установить значения массива типа «int» по своему выбору, предопределенные, а также определенные в программе или во время выполнения. Удаление массива относится к удалению всего массива из программы, не влияя на код, последовательность и логику программы.
Когда мы инициализировали новый массив, накопилось динамическое выделение памяти, которое помещает переменные в память кучи. Это захватывает длинную память, когда вы определяете массив в коде из кучи. Внутри оператора удаления есть возвращаемый тип void, который не возвращает какое-либо значение функции. Delete[] — это оператор, функция которого заключается в удалении массива, созданного новыми выражениями.
Необходимость удаления объекта
В языках программирования память является основным моментом. Мы должны получить как можно меньше памяти. Чтобы избежать потери памяти, когда массив создается статически или динамически с использованием нового или просто инициализируется, он захватывает память в секции кучи. Если вещи в это время не убрать, код на время исполнения взломает. После удаления массива все элементы массива также удаляются из памяти. Код в приведенных ниже примерах поможет вам понять эту логику.
В этой статье давайте обсудим разные подходы к удалению массива из памяти с помощью очень простого метода на C++.
Удаление пустых объектов массива
Удаление массивов во всех языках — это сольный момент объекта в коде, который можно было сделать в начале программы. Также во время выполнения при использовании оператора с термином «новый» оператор удаляется оператором удаления. С другой стороны, массив объектов удаляется с помощью оператора delete[], после чего не может привести к утечке памяти. Здесь мы используем простой и базовый пример удаления массива с помощью квадратных скобок [], но сначала мы используем предел массива 10, а затем удаляем массив.
Во-первых, используется заголовочный файл #include. В основном теле мы берем пустой массив с именем «myarray». Затем мы показываем сообщения. После этого пишем оператор delete[] и передаем ему «myarray». Массив успешно удален из памяти.
Так как массив пустой и в массиве нет элемента, то мы и не отображали массив. Элементы будут показаны на следующей иллюстрации.
Удаление объекта массива, имеющего значения
Подтверждено, что каждый элемент массива удаляется, когда вы удаляете массив с помощью оператора delete[], либо он пуст, либо заполнен. Существует универсальное правило: вы должны аккуратно удалить те объекты, которые вы выделили оператором new. Здесь мы видим пример удаления массива со значениями, а не пустого массива. Для каждого типа массива функция удаления массива одинакова.
В основной части мы берем переменную «i» цикла и массив с именем «arr» и длиной 5, содержащий элементы от 1 до 5. Затем мы написали цикл «for», чтобы показать элементы массив, чтобы проверить, пуст ли наш массив или нет. После этого оператор delete[] выполняет свои функции. Вот так наш массив удаляется.
Здесь легко увидеть элементы массива, который был инициализирован при старте программы.
Удаление нескольких массивов
Наконец, здесь мы объясняем, как удалить два или более массива в одной программе. Переменная, тип данных которой определяется пользователем, содержит фактические данные, а не указывает на данные. Во всех языках программирования указатели также являются переменными, но имеют адреса других дополнительных переменных. Здесь a* — переменная-указатель, а array1 и array2 — массив целых чисел. Строка кода, где a* = array1 получает адрес самого первого компонента массива в переменной a.
После использования файлов заголовков мы определяем структуру с переменной «a». В этой структуре мы объявляем две статические функции и передаем аргумент указателя, а также переменную размером с массив. Единственный объект кода создается во время выполнения на C++ с использованием оператора new. В функции мы отображаем наши статические массивы. В основном теле мы берем объект-указатель и два массива с именами array1 и array2 соответственно, которые имеют разные размеры. После этого мы используем оператор удаления [] для удаления массива.
Здесь мы получаем первый массив с помощью объекта и удаляем его, а затем второй массив снова с помощью объекта и удаляем его.
Заключение
В этой статье описывался массив и удаление массивов в языке C++. Мы также обсудили, почему нам нужно удалить массив с помощью нескольких подходов, которые используются для удаления массива в C++. Мы удаляем массив, не имеющий значения, а также добавляем элементы в массив, а затем удаляем его последним с помощью указателя. По этой статье мы понимаем, что мы также можем удалять два или более массива одновременно с помощью объектов.
Как удалить массив в PHP?
В этом уроке вы не только узнаете, как удалить массив PHP, но и как удалить один или несколько элементов массива разными способами. Начнем с простого:
- Для того, чтобы удалить один из элементов массива, воспользуемся функцией unset():
- Для удаления нескольких непоследовательных элементов также пригодится функция unset():
- Для удаления нескольких последовательных элементов используйте функцию array_splice():
- Для того, чтобы удалить массив полностью, необходимо воспользоваться той же функцией UnSet(), аргументом которой будет сам удаляемый массив. Вот пример удаления массива:
Есть логическое отличие между использованием функции unset() и присваиванием элементу пустой строки (»). В первом случае говорится: «Этого элемента больше не существует», а во втором – «Этот элемент еще существует, но его значение равно пустой строке».
После применения функции unset() к какому-либо элементу массива, PHP корректирует его так, чтобы цикл продолжал правильно работать. Он не сжимает массив для заполнения пустого пространства, поэтому, можно утверждать, что все массивы являются ассоциативными, даже если кажутся числовыми. Например:
Используем функцию array_values(), для того, чтобы сжать массив до плотно заполненного числового массива:
Функция array_splice() автоматически реиндексирует массив, чтобы не оставлять «дыр»:
Это полезно, если работать с массивом как с очередью, разрешая произвольный доступ. Для безопасного удаления первого или последнего элемента массива применяются функции array_shift() и array_pop()