Блуждающие, дикие или зависшие указатели — КиберПедия 

Организация стока поверхностных вод: Наибольшее количество влаги на земном шаре испаряется с поверхности морей и океанов (88‰)...

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

Блуждающие, дикие или зависшие указатели



 

Блуждающие указатели являются достаточно распространенной ошибкой программистов, обнаружить которую довольно сложно. Блуждающий (либо, как его еще называют, дикий или зависший) указатель возникает, если после удаления объекта оператором delete этому указателю не присвоить значение 0. При попытке использовать такой указатель в дальнейшем результат может оказаться непредсказуемым. В лучшем случае программа завершится сообщением об ошибке.

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

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

Пример возникновения блуждающего указателя показан в листинге 8.9.

Листинг 8.9. Пример возникновения блуждающего указателя

1: // Листинг 8.9.

2: // Пример возникновения блуждающего указателя

3: typedef unsigned short int USHORT;

4: #include <iostream.h>

5:

6: int main()

7: {

8: USHORT * pInt = new USHORT;

9: *pInt = 10;

10: cout << "*pInt; " << *pInt << endl;

11: delete pInt;

12:

13: long * pLong = new long;

14: *pLong = 90000;

15: cout << "*pLong: " << *pLong << endl;

16:

17: *pInt = 20; // Присвоение освобожденному указателю

18:

19: cout << "*pInt: " << *pInt << endl;

20: cout << "*pLong: " << *pLong << endl;

21: delete pLong;

22: return 0;

23: }

 

Результат:

*pInt: 10

*pLong: 90000

*pInt: 20

*pLong: 65556

(Ваши результаты могут отличаться от приведенных.)

 

Анализ: В строке 8 переменная pInt объявляется как указатель на тип USH0RT. Выделяется память для хранения этого типа данных. В строке 9 по адресу в этом указателе записывается значение 10, а в строке 10 оно выводится на экран. Затем память, выделенная для pInt, освобождается оператором delete. После этого указатель оказывается зависшим, или блуждающим.

В сроке 13 объявляется новый указатель (pLong) и ему присваивается адрес выделенной оператором new области памяти. В строке 14 по адресу в указателе записывается число 90000, а в строке 15 это значение выводится на экран.



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

В строке 19 новое значение pInt выводится на экран. Это значение, как и ожидалось, равно 20. В строке 20 выводится значение указателя pLong. К удивлению, обнаруживаем, что оно равно 65556. Возникает два вопроса.

1. Как могло измениться значение pLong, если мы его даже не использовали?

2. Куда делось число 20, присвоенное в строке 17?

Как вы, наверное, догадались, эти два вопроса связаны. При присвоении в строке 17 число 20 записывается в область памяти, на которую до этого указывал pInt. Но, так как память была освобождена в строке 11, компилятор использовал эту область для записи других данных. При объявлении указателя pLong (строка 13) была зарезервирована область памяти, на которую раньше ссылался указатель pInt. Заметим, что на некоторых компьютерах этого могло не произойти. Записывая число 20 по адресу, на который до этого указывал pInt, мы искажаем значение pLong, хранящееся по этому же адресу. Вот к чему может привести некорректное использование блуждающих указателей.

Локализовать такую ошибку достаточно сложно, поскольку искаженное значение никак не связано с блуждающим указателем. Результатом некорректного использования указателя pInt стало изменение значения pLong. В больших программах отследить возникновение подобной ситуации особенно сложно.

В качестве небольшого отступления рассмотрим, как по адресу в указателе pLong оказалось число 65556.

1. Указатель pInt ссылается на область памяти, в которую мы записали число 10.



2. Оператором delete мы позволяем компилятору использовать эту память для хранения других данных. Далее по этому же адресу записывается значение pLong.

3. Переменной *pLong присваивается значение 90000. Поскольку в компьютере использовалось четырехбайтовое представление типа long с перестановкой байтов, на машинном уровне число 90000 (00 01 5F 90) выглядело как 5F 90 00 01.

4. Затем указателю pInt присваивается значение 20, что эквивалентно 00 14 в шестнадцатеричной системе. Вследствие того что указатели ссылаются на одну и ту же область памяти, два первых байта числа 90000 перезаписываются. В результате получаем ЧИСЛО 00 14 00 01.

5. При выводе на экран значения в указателе pLong порядок байтов изменяется на 00 01 00 14, что эквивалентно числу 65556.

 

Рекомендуется: Создавайте объекты в области динамического обмена.

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

Не рекомендуется: Не забывайте каждое выделение свободной памяти с помощью оператора new сопроводить освобождением памяти с помощью оператора delete. Незабывайте присваивать освобожденным указателям нулевые значения.

 

Вопросы и ответы: Какая разница между пустым и блуждающим указателями?

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

Присваивая указателю нулевое значение, например следующим выражением: myPtr - 0:, вы тем самым превращаете блуждающий указатель в нулевой. Еще одна опасность блуждающих указателей состоит в том, что, дважды применив к одному и тому же указателю оператор delete, вы тем самым создадите неопределенную ситуацию, которая может привести к зависанию программы. Этого не случится, если освобожденному указателю будет присвоено нулевое значение. Присвоение освобожденному указателю — как блуждающему, так и нулевому — ново- го значения (т.е. использование выражения myPt r = 5) недопустимо, но если в случае с пустым указателем об этом вам сообщит компилятор, то в случае с блуждающим указателем вы узнаете об этом по зависанию программы в самый неподходящий момент.

 






Папиллярные узоры пальцев рук - маркер спортивных способностей: дерматоглифические признаки формируются на 3-5 месяце беременности, не изменяются в течение жизни...

Организация стока поверхностных вод: Наибольшее количество влаги на земном шаре испаряется с поверхности морей и океанов (88‰)...

Кормораздатчик мобильный электрифицированный: схема и процесс работы устройства...

Индивидуальные и групповые автопоилки: для животных. Схемы и конструкции...





© cyberpedia.su 2017 - Не является автором материалов. Исключительное право сохранено за автором текста.
Если вы не хотите, чтобы данный материал был у нас на сайте, перейдите по ссылке: Нарушение авторских прав

0.006 с.