С++ удалить. Он удаляет мои объекты, но я все еще могу получить доступ к данным?

Ожидается ли возможность доступа к данным из загробного мира?

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

Ожидается ли возможность доступа к данным из загробного мира?

В большинстве случаев да. Вызов удаления не обнуляет память.

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

Если подумать, то логично — когда вы говорите компилятору, что память вас больше не интересует (используя delete), зачем компьютеру тратить время на ее обнуление.

Удалить ничего не удаляет — она просто помечает память как «свободную для повторного использования». Пока какой-либо другой вызов распределения не зарезервирует и не заполнит это пространство, у него будут старые данные. Тем не менее, полагаться на это - большое нет-нет, в основном, если вы что-то удаляете, забудьте об этом.

Одной из практик в этом отношении, которая часто встречается в библиотеках, является функция Delete:

template< class T > void Delete( T*& pointer )
{
    delete pointer;
    pointer = NULL;
}

Это предотвращает случайное обращение к недопустимой памяти.

Обратите внимание, что совершенно нормально вызывать delete NULL;.

Это то, что C++ называет неопределенным поведением — вы можете получить доступ к данным, а можете и нет. В любом случае, это неправильно.

Куча памяти похожа на кучу классных досок. Представьте, что вы учитель. Пока вы учите свой класс, классная доска принадлежит вам, и вы можете делать с ней все, что хотите. Вы можете писать на нем и перезаписывать что хотите.

Когда урок окончен и вы собираетесь покинуть класс, нет правил, требующих, чтобы вы стирали доску — вы просто передаете доску следующему учителю, который, как правило, может видеть то, что вы записали.

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

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

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

delete освобождает память, но не изменяет ее и не обнуляет. Тем не менее, вы не должны обращаться к освобожденной памяти.

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

Он пока не обнулит/изменит память... но в какой-то момент коврик выпадет у вас из-под ног.

Нет, это, конечно, непредсказуемо: это зависит от того, насколько быстро происходит выделение/освобождение памяти.

Хотя возможно, что ваша среда выполнения не сообщает об этой ошибке, использование надлежащей среды выполнения для проверки ошибок, такой как Valgrind, предупредит вас об использовании памяти после ее освобождения.

Я рекомендую, если вы пишете код с new/delete и необработанными указателями (а не std::make_shared() и подобными), выполнять модульные тесты под Valgrind, чтобы хотя бы иметь шанс обнаружить такие ошибки.

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

Если вы хотите обнулить его, выполните:

SingleBlock::~SingleBlock()

{    x = y = 0 ; }

Ну, я тоже давно задавался этим вопросом, и я попытался провести несколько тестов, чтобы лучше понять, что происходит под капотом. Стандартный ответ заключается в том, что после вызова delete не следует ожидать ничего хорошего от доступа к этому участку памяти. Однако этого мне показалось мало. Что на самом деле происходит при вызове delete(ptr)? Вот что я нашел. Я использую g++ в Ubuntu 16.04, так что это может сыграть роль в результатах.

При использовании оператора удаления я сначала ожидал, что освобожденная память будет возвращена системе для использования в других процессах. Позвольте мне сказать, что это не происходит ни при каких обстоятельствах, которые я пробовал.

Память, освобожденная с помощью delete, по-прежнему кажется выделенной программе, которая сначала выделила ее с помощью new. Я пробовал, и после вызова delete использование памяти не уменьшилось. У меня было программное обеспечение, которое выделяло около 30 МБ списков с помощью вызовов new, а затем освобождало их с последующими вызовами delete. Что произошло, так это то, что, глядя на системный монитор во время работы программы, даже длительный сон после вызовов delete, потребление памяти моей программой было одинаковым. Без снижения! Это означает, что delete не освобождает память для системы.

На самом деле, похоже, что память, выделенная программой, принадлежит ему навсегда! Однако дело в том, что в случае освобождения память может быть снова использована той же программой без дополнительного выделения. Я попытался выделить 15 МБ, освободив их, а затем выделив еще 15 МБ данных, и программа никогда не использовала 30 МБ. Системный монитор всегда показывал около 15 МБ. Что я сделал в отношении предыдущего теста, так это просто изменил порядок, в котором происходили события: половина распределения, половина освобождения, другая половина распределения.

Таким образом, очевидно, память, используемая программой, может увеличиваться, но никогда не уменьшаться. Я подумал, что, возможно, память действительно будет освобождаться для других процессов в критических ситуациях, например, когда памяти больше не будет. В конце концов, какой смысл позволять программе вечно хранить свою память, когда об этом просят другие процессы? Поэтому я снова выделил 30 МБ и освобождая их, запускаю memtester с максимально возможным объемом физической памяти. Я ожидал, что мое программное обеспечение передаст свою память мемтестеру. Но угадайте, этого не произошло!

Я сделал небольшой скринкаст, который показывает, как это работает:

Если быть на 100% честным, была ситуация, в которой что-то произошло. Когда я попробовал memtester с большим, чем доступная физическая память, в середине процесса освобождения моей программы, память, используемая моей программой, упала примерно до 3 МБ. Однако процесс memtester был автоматически убит, и то, что произошло, было еще более удивительным! Использование памяти моей программой увеличивалось с каждым вызовом удаления! Это было так, как если бы Ubuntu восстанавливала всю свою память после инцидента с memtester.

Взято с сайта http://www.thecrowned.org/c-delete-operator-really-frees-memory