Операция delete[] не до конца удаляет динамический массив?

Здравствуйте. Только учусь программировать. Поэтому такой вопрос: вот следующий код, в строке 19, когда компилятор выводит удаленный массив на экран (просто для интереса, что будет), последнее значение равно последнему значению массива до удаления. Что это, совпадение? Я компилировала несколько раз, с разным количеством значений массива (n) и всегда, значения, которые n>=5 удаленного массива равнялись значениям массива до удаления. Это значит что операция delete[] удаляет только первые 4 значения массива. У всех так? Если да, то почему? Это же утечка памяти. Если нет, то может дело в компиляторе или в архитектуре процессора или еще в чем-то?

0

Сообщение от A1ena Это значит что операция delete[] удаляет только первые 4 значения массива.

??? Что по-вашему означает слова "удаляет"? Выжигает черную дыру в памяти компьютера, с образованием облака черного дыма? Почему вы ожидаете, что данные в "удаленной" области памяти должны как-то поменяться? Откуда возникли такие ожидания?

В любом случае, вам не разрешается осуществлять доступ к памяти после delete[], поэтому вопросы того, что там хранится или поменялось ли там что-то, вас волновать не должны. Строка 19 вашего кода имеет неопределенное поведение. Что бы она там ни делала - это ничего не значит.

Сообщение от A1ena удаляет только первые 4 значения массива.

Почему вы решили, что первые 4 значения "удалились", если, как вы сами сказали, они на самом деле просто поменялись на другие значения? Еще раз: что по вашему значит слово "удалять"?

Сообщение от A1ena Это же утечка памяти.

С чего бы это вдруг?

1

Сообщение от A1ena совпадение?

В некотором роде)
Когда вы удаляете память, то она физически не уничтожается. Она просто помечается свободной, и может отдана кому-то ещё, и быть перезаписана. Но это не обязательно происходит сразу же. Какое то время память может содержать старые значения, которые были до удаления.

1

хорошо, я могу неправильно понимать значение "утечка памяти". В моем понимании, что операция delete[] удаляет значения массива, чтобы не было утечки памяти, если этот массив больше не нужен. Задам вопрос по-другому. Почему после удаления, первые 4 значения удаленного массива не равны первым 4 значениям массива до удаления, а после 4 значения, все равны?

0

Сообщение от A1ena Почему после удаления

неопределённое поведение же

1

TheCalligrapher,
хорошо, я могу неправильно понимать значение "утечка памяти". В моем понимании, что операция delete[] удаляет значения массива, хрянящиеся по адресу указателя и удаляет сам указатель.
Задам вопрос по-другому. Почему после удаления, первые 4 значения удаленного массива не равны первым 4 значениям массива до удаления, а после 4 значения, все равны?

0

A1ena, Нет фиксированного объяснения почему имеено после 4 значения, может быть много причин, от архитектуры процессора до оптимизации компилятора.

1

Сообщение от A1ena В моем понимании, что операция delete[] удаляет значения массива, чтобы не было утечки памяти, если этот массив больше не нужен. Задам вопрос по-другому. Почему после удаления, первые 4 значения удаленного массива не равны первым 4 значениям массива до удаления, а после 4 значения, все равны?

"Удаляет" - значить каким-то образом помечает память как свободную для дальнейшего использования. Пока это "дальнейшее использование" не наступит, нет никакой причины как-то менять данные в "удаленной" памяти. Ваши старые данные будут продолжать лежать в этой памяти, пока их кто-то не перезапишет.

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

При желании, вы можете почитать литературу по внутреннему устройству популярных механизмов динамического распределения памяти. Там вы найдете и объяснение того, почему поменялись начальные байты. Но к языку С++ это прямого отношения не имеет.

Сообщение от A1ena В моем понимании, что операция delete[] удаляет значения массива, хрянящиеся по адресу указателя и удаляет сам указатель.

"и удаляет сам указатель"? Это уже совсем не верно. С самим указателем операция delete[] ничего не делает вообще. Операция delete[] лишь удаляет массив, на начало которого указывал указатель. Вот и все. Указатель после этого становится "неопределенным", но это лишь побочный эффект уничтожения массива. Операция delete[] напрямую ничего с указателем не делает и не может делать. Она не "удаляет сам указатель". Это - бессмыслица.

1

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

0

Сообщение от A1ena . В моем понимании, что операция delete[] удаляет значения массива

Нет. Операция delete[] делает следующее:
1) Разрушает объект, на который указывает указатель (в данном случае объект - это массив, а значит разрушение массива повлечет за собой разрушение его элементов);
2) Освобождает память, выделенную для массива.
*) Сам указатель никто не трогает, однако значение адреса, которое он содержит, перестает быть корректным и его больше нельзя использовать.

Теперь нужно разобраться что значит
1) Разрушает;
2) Освобождает.

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

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

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

1

DrOffset, а в чем смысл, когда люди после delete или delete[] присваивают указателю nullptr?

0

TheCalligrapher, спасибо. это будет следующий этап, сначала мне нужно изучить синтаксис с++. Теперь я поняла, как работает delete[]. Он не удаляет, а помечает область памяти как свободную

0

Сообщение от Royal_X а в чем смысл, когда люди после delete или delete[] присваивают указателю nullptr?

Ну, очевидно, чтобы получить валидный указатель, со значением nullptr.

0

Сообщение от DrOffset чтобы получить валидный указатель, со значением nullptr.

типа, чтобы проверять его потом?

0

Сообщение от Royal_X а в чем смысл, когда люди после delete или delete[] присваивают указателю nullptr?

Ну, например, затем чтобы потом где-то проверить if (указатель == nullptr). Или затем, чтобы если где-то ниже есть еще один delete[] на этот указатель, не получилось "двойного удаления". Можно придумать много причин...

0

TheCalligrapher, т.е. после delete у нас dangling pointer. Как только мы присваиваем nullptr, то снова он валидный указатель и с ним можно работать?

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

0

DrOffset, спасибо за такой развернутый ответ

0

Сообщение от Royal_X это говнокод?

Без контекста? Нет. Т.е. неизвестно.
Однако значение x после block-scope использовать нельзя - это факт.

Добавлено через 1 минуту

Сообщение от Royal_X delete x; // так можно?

Нет, конечно.

0

Сообщение от DrOffset после block-scope использовать нельзя - это факт.

а delete x; можно?

Добавлено через 48 секунд

Сообщение от DrOffset Нет, конечно.

а как его снова сделать валидным, не трогая block-scope? типа присвоить nullptr?

0

Сообщение от Royal_X а delete x; можно?

Нельзя. Значение x же изменилось в block-scope.

Добавлено через 30 секунд

Сообщение от Royal_X а как его снова сделать валидным, не трогая block-scope?

1