С помощью чего выявляются логические ошибки в программе

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

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

Отладка и обработка ошибок в программе

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

Все ошибки можно разделить на три большие группы:

— синтаксические (неправильно написан оператор, имя переменной и т. п.). Такие ошибки не требуют больших усилий по их поиску и исправлению. Многие синтаксические ошибки «отлавливаются» редактором кода VBA еще в процессе ввода кода. Об обнаружении других ошибок сообщается в ходе компиляции и запуска программы. При этом компилятор VBA выдает информацию о том, в какой строке кода обнаружена ошибка и в чем она заключается. Рекомендуется проверить данную строку по справке VBA;

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

— ошибки времени выполнения (run-time error). Они возникают, когда в процессе выполнения программа столкнулась с проблемой, решить которую она не в состоянии (файл с таким именем уже существует, возник конфликт записей при вставке в базу данных, произведена попытка записать информацию на переполненный диск и т. п.). Заранее предугадать, какая именно неприятность может случиться, очень сложно. Во многом квалификация программиста определяется тем, как он умеет предугадывать возможности возникновения ошибок времени выполнения и обеспечивать

их перехват и обработку.

Если программа делается «для себя» (для автоматизации работы того пользователя, который пишет эту программу), то очень часто перехват ошибок времени выполнения вообще не предусматривается. Возникла ошибка – ничего страшного: открыли программу в отладчике, посмотрели, отчего возникла ошибка, и «исправились». Но если программа пишется для передачи другим пользователям (особенно не очень квалифицированным), то на реализацию обработки ошибок времени выполнения обычно уходит больше времени, чем на создание самой логики программы.

Окна Immediate, Locals и Watch

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

— попытайтесь запустить программу при работе с большим количеством документов или когда не открыто ни одного документа;

— посмотрите, как работает программа, когда окно документа развернуто, свернуто или размер его изменен;

— проверьте, как работает программа, когда выделены разные элементы или группы элементов;

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

— попробуйте прервать работу программы в самый неподходящий момент и потом вновь запустить ее;

— проверьте, как ведет себя программа, когда пропадает сеть, заканчивается свободное место на диске, заканчивается бумага в принтере и т. п.;

— проверьте работу программы под разными версиями Office и операционных систем (в том числе англоязычных и локализованных);

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

Мне очень нравится «диверсионный» подход при тестировании программ. Представьте себе, что вы — вредитель и диверсант, у которого цель- вывести программу из строя. Потом опробуйте те способы, которые вам пришли в голову. Если способ оказался удачным, придумайте для него защиту. Как ни удивительно, но реальная работа пользователей с вашей программой будет очень похожа на действия таких диверсантов.

Отладка программы – это процесс поиска и устранения ошибок. Часть ошибок формального характера, связанных с нарушением правил записи конструкций языка или отсутствием необходимых описаний, обнаруживает транслятор, производя синтаксический анализ текста программы. Транслятор выявляет ошибки и сообщает о них, указывая их тип и место в программе. Такие ошибки называются ошибками времени трансляции или синтаксическими ошибками.

Ошибочные ситуации могут возникнуть и при выполнении программы, например, деление на нуль или извлечение корня квадратного из отрицательного числа. Такие ошибки называются ошибками времени выполнения.

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

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

а) проверить все возможные режимы работы программы;

б) по возможности, локализовать ошибку.

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

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

33. ВИДЫ ОШИБОК В ПРОГРАММАХ

Об ошибках в программе сигнализируют некорректная работоспособность программы либо ее полное невыполнение. В наше время для обозначения ошибки в программе используют термин «Баг» (с англ. Bug-жук).

Есть несколько типов ошибок:

1) Логическая ошибка. Это, пожалуй, наиболее серьезная из всех ошибок. Когда написанная программа на любом языке компилирует и работает правильно, но выдает неправильный вывод, недостаток заключается в логике основного программирования. Это ошибка, которая была унаследована от недостатка в базовом алгоритме. Сама логика, на которой базируется вся программа, является ущербной. Чтобы найти решение такой ошибки нужно фундаментальное изменение алгоритма. Вам нужно начать копать в алгоритмическом уровне, чтобы сузить область поиска такой ошибки. (пример: задача программы вывести сумму двух чисел а и b.

2) Синтаксическая ошибка. Каждый компьютерный язык, такой как C, Java, Perl и Python имеет специфический синтаксис, в котором будет написан код. Когда программист не придерживаться «грамматики» спецификациями компьютерного языка, возникнет ошибка синтаксиса. Такого рода ошибки легко устраняются на этапе компиляции.

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

4) Ошибки среды выполнения (RunTime). Программный код успешно скомпилирован, и исполняемый файл был создан. Вы можете вздохнуть с облегчением и запустить программу, чтобы проверить ее работу. Ошибки при выполнении программы могут возникнуть в результате аварии или нехватки ресурсов носителя. Разработчик должен был предвидеть реальные условия развертывания программы. Это можно исправить, вернувшись к стадии кодирования.

5) Арифметическая ошибка. Многие программы используют числовые переменные, и алгоритм может включать несколько математических вычислений. Арифметические ошибки возникают, когда компьютер не может справиться с проблемами, такими как «Деление на ноль», или ведущие к бесконечному результату. Это снова логическая ошибка, которая может быть исправлена только путем изменения алгоритма.

6) Ошибки ресурса. Ошибка ресурса возникает, когда значение переменной переполняет максимально допустимое значение. Переполнение буфера, использование неинициализированной переменной, нарушение прав доступа и переполнение стека — примеры некоторых распространенных ошибок.

7) Ошибка взаимодействия. Они могут возникнуть в связи с несоответствием программного обеспечения с аппаратным интерфейсом или интерфейсом прикладного программирования. В случае веб-приложений, ошибка интерфейса может быть результатом неправильного использования веб-протоколов

Синтаксические ошибки – это ошибки в записи конструкций языка программирования (чисел, переменных, функций, выражений, операторов, меток, подпрограмм).

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

Читать также:  CrystalDiskInfo

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

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

Существует
3 способа отладки программы:

Пошаговая
отладка программ с заходом в подпрограммы;

Пошаговая
отладка программ с выполнением
подпрограммы как одного оператора;

Выполнение
программы до точки остановки.

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

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

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

Тестирование
— это динамический контроль программы,
т.е. проверка правильности программы
при ее выполнении на компьютере.

Каждому
программисту известно, сколько времени
и сил уходит на отладку и тестирование
программ. На этот этап приходится около
50% общей стоимости разработки программного
обеспечения. Но не каждый из разработчиков
программных средств может верно,
определить цель тестирования. Нередко
можно услышать, что тестирование — это
процесс выполнения программы с целью
обнаружения в ней ошибок. Но эта цель
недостижима: ни какое самое тщательное
тестирование не дает гарантии, что
программа не содержит ошибок. Другое
определение: это процесс выполнения
программы с целью обнаружения в ней
ошибок. Отсюда ясно, что “удачным”
тестом является такой, на котором
выполнение программы завершилось с
ошибкой. Напротив, “неудачным” можно
назвать тест, не позволивший выявить
ошибку в программе. Определение также
указывает на объективную трудность
тестирования: это деструктивный ( т.е.
обратный созидательному ) процесс.
Поскольку программирование — процесс
конструктивный, ясно, что большинству
разработчиков программных средств
сложно “переключиться” при тестировании
созданной ими продукции. Основные
принципы организации тестирования:

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

следует
по возможности избегать тестирования
программы ее автором, т.к. кроме уже
указанной объективной сложности
тестирования для программистов здесь
присутствует и тот фактор, что обнаружение
недостатков в своей деятельности
противоречит человеческой психологии
(однако отладка программы эффективнее
всего выполняется именно автором
программы);

по
тем же соображениям организация —
разработчик программного обеспечения
не должна “единолично ” его тестировать
(должны существовать организации,
специализирующиеся на тестировании
программных средств);

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

необходимо
тщательно подбирать тест не только для
правильных (предусмотренных ) входных
данных, но и для неправильных
(непредусмотренных);

при
анализе результатов каждого теста
необходимо проверять, не делает ли
программа того, что она не должна делать;

следует
сохранять использованные тесты (для
повышения эффективности повторного
тестирования программы после ее
модификации или установки у заказчика);

тестирования
не должно планироваться исходя из
предположения, что в программе не будут
обнаружены ошибки (в частности, следует
выделять для тестирования достаточные
временные и материальные ресурсы);

следует
учитывать так называемый “принцип
скопления ошибок” : вероятность наличия
не обнаруженных ошибок в некоторой
части программы прямо пропорциональна
числу ошибок, уже обнаруженных в этой
части;

следует
всегда помнить, что тестирование —
творческий процесс, а не относиться к
нему как к рутинному занятию.

Существует
два основных вида тестирования:
функциональное и структурное. При
функциональном тестировании программа
рассматривается как “черный ящик”
(то есть ее текст не используется).
Происходит проверка соответствия
поведения программы ее внешней
спецификации. Возможно ли при этом
полное тестирование программы? Очевидно,
что критерием полноты тестирования в
этом случае являлся бы перебор всех
возможных значений входных данных, что
невыполнимо.

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

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

тестирование
функций программного комплекса (т.е.
поиск различий между разработанной
программой и ее внешней спецификацией
);

тестирование
всего комплекса в целом (т.е. поиск
несоответствия созданного программного
продукта, сформулированным ранее целям
проектирования, отраженным обычно в
техническом задании).

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

12.
Данные в языке Си: константы и переменные.
Скалярные типы данных. Модификаторы
типов.

13.
Данные числовых типов в языке Си:
объявление, характеристика, допустимые
операции, приведение типов. Пример
использования.

14.
Операции языка Си. Приоритет операций.
Оператор и операция присваивания в
языке операции, приведение типов. Пример
использования.

Выражение
может быть просто константой или сколь
угодно сложным выражением. В отличие
от Pascal или Modula-2, в которых для присваивания
используется знак «:=», в языке С
оператором присваивания служит
единственный знак присваивания
«=». Адресатом(получателем),
т.е. левой частью оператора присваивания
должен быть объект, способный получить
значение, например, переменная.

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

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

Самым простым
способом локализации логической ошибки
является пошаговое прослеживание
результатов выполнения всех операторов
программы. При
отладке приложения в VS
можно отображать
значения указанных переменных или
выражений в любой точке программы.

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

Первый шаг отладки
приложения – это выбор команды Start
Debugging
(F5) на стандартной
панели инструментов или в меню Debug,
после чего приложение запускается в
режиме отладки.

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

Для того чтобы
отладчик прерывал выполнение программы
на определенной строке, необходимо
установить на этой строке точку
останова.
Точка останова
– это просто
место (например, строка с оператором
программы), которое помечено для отладчика
и отображается красным кружком в поле
индикаторов (узкое
поле серого цвета с левого края окна
редактора кода). Когда отладчик встречает
точку останова, то выполняющаяся
программа моментально останавливается
(до выполнения данной строки кода).

Установить точку
останова на какой-либо строке кода можно
при помощи щелчка по полю индикаторов
данной строки (рис. 16). Либо можно
установить курсор на нужной строке и
нажать клавишу F9.

С помощью чего выявляются логические ошибки в программе

Просмотр
данных в отладчике

Когда выполнение
программы в сеансе отладки приостановлено
(например,
при помощи точки
останова), можно
изучить состояние и содержимое ее
переменных и объектов.
Для этого в VS
можно использовать
три вида окон:
Local
(Локальные),
Autos
(Видимые)
и Watch
(Контрольные).

Читать также:  Пишите. Исправляйте. Парафразируйте

С помощью чего выявляются логические ошибки в программе

Рисунок 17. Доступ к
окнам

Окно Local
показывает
все переменные и их значения для текущей
области видимости отладчика.
Это дает вам
представление обо всем,
что имеется в
текущей выполняющейся функции.
Переменные в
этом окне организованы в список и
автоматически настраиваются отладчиком.
На рис.
18 показан пример
окна Local.
С его помощью
можно увидеть приложение нашего примера,
которое
приостановлено до обнуления соответствующих
элементов массива.
Обратите внимание,
что объект
(массив)
a
развернут для
того, чтобы
показать значения его элементов в момент
остановки выполнения программы.
По мере установки
значений результаты будут отображаться
в столбце Value.

Однако очень часто
просмотр всех локальных переменных
дает слишком много информации, чтобы в
ней можно было разобраться. Так может
происходить тогда, когда в области
видимости данного процесса или функции
находится слишком много операторов.
Для того

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

показано окно Autos
для той же
самой строки кода, которая показана на
рис. 18. Обратите внимание на разницу.

Окна Watch
в VS позволяют
настраивать собственный список переменных
и выражений, за которыми нужно наблюдать
(рис. 20). Окна Watch
выглядят и
ведут себя точно так же, как и окна Local
и Autos.
Кроме того, те элементы, которые вы
размещаете в окнах Watch,
сохраняются между сеансами отладки.

С помощью чего выявляются логические ошибки в программе

С помощью чего выявляются логические ошибки в программе

Вы получаете доступ
к окнам Watch
из меню или панели инструментов Debug
(рис. 17).
Четыре окна Watch
(которые называются Watch
1, Watch
2, Watch
3 и Watch
4) позволяют
настроить четыре списка элементов, за
которыми необходимо наблюдать. Эта
возможность может быть особенно полезна
в том случае, когда каждый список
относится к отдельной области видимости
вашего приложения.

Переменную или
выражение в окно Watch
1 можно добавить
из редактора кода. Для этого в редакторе
кода выделите переменную (или выражение),
щелкните по ней правой кнопкой мыши и
выберите пункт Add
Watch.
При этом выделенная переменная (или
выражение) будет помещена в окно Watch
1. Вы можете
также перетащить выделенный элемент в
это окно.

С помощью чего выявляются логические ошибки в программе

Пошаговое
прохождение для поиска ошибки

После того как в
нашем примере отладчик,
встретив точку
останова, прервал
выполнение программы,
далее можно
выполнять код по шагам (режим
трассировки).
Для этого можно
выбрать команду Step
into
на панели
инструментов Debug
или нажать
функциональную клавишу F11(Рис.
21). Это приведет
к последовательному выполнению кода
по одной строке,
что позволит
вам видеть одновременно и ход выполнения
приложения, и
состояние объектов программы по мере
выполнения кода.
Команда Step
into
(F11) позволяет
продвигаться по коду по одной строке.
Вызов этой
команды выполнит текущую строку кода
и поместит курсор на следующую выполняемую
строку. Важное
различие между Step
into
и другими
похожими командами состоит в

том,
как Step
into
обрабатывает
строки кода, в
которых содержатся вызовы функций.
Если вы находитесь
на строке кода,
которая вызывает
другую функцию программы,
то выполнение
команды Step
into
перенесет вас
на первую строку этой функции.

Если сделать так в
нашем примере,
то вы увидите
ошибку: обнуление
элементов массива должно начинаться
не с элемента с индексом i1,
а со следующего
элемента i1+1.

Команда Step
out
(F10) позволяет
вам сохранять фокус в текущей функции
(не заходя в вызываемые ею подпрограммы),
т. е. вызов Run
out
приведет к
выполнению строки за строкой, но не
заведет вас в вызовы функций и при этом
следующей выполняемой

строкой для пошагового
прохождения станет следующая за вызовом
функции строка.

С помощью чего выявляются логические ошибки в программе

Рис 21. Команда Step
Into

Одной из более
удобных (и
часто упускаемых)
функциональных
возможностей набора инструментов
отладки является функция Run
to
cursor
( Выполнить до текущей позиции).
Она работает в
полном соответствии со своим названием.
Вы устанавливаете
курсор на некий код и вызываете эту
команду. Приложение
компилируется и выполняется до тех пор,
пока не доходит
до той строки,
где находится
курсор. В
этой точке отладчик прерывает приложение
и выдает вам эту строку кода для пошагового
прохождения.
Рис. 22.

С помощью чего выявляются логические ошибки в программе

Рисунок 22. Вызов
команды Run
To
Cursor

Продолжить отладку
после точки останова можно повторным
нажатием на кнопку F5 (Start
Debugging).

С помощью чего выявляются логические ошибки в программе

Рисунок 23. Результат
работы программы после исправления
ошибки

Рассмотрим пошаговое
выполнение программы с использованием
окна Watch
на простейшем примере.

С помощью чего выявляются логические ошибки в программе

Рисунок 24. Окно
редактора кода в начале трассировки.

С помощью чего выявляются логические ошибки в программе

Рисунок 25. Значение
переменных перед первым прохождением
цикла

С помощью чего выявляются логические ошибки в программе

Рисунок 26. Окно
редактора кода перед первым прохождением
цикла

С помощью чего выявляются логические ошибки в программе

Рисунок
27. Значения переменных после выполнения
операции а=а+1

С помощью чего выявляются логические ошибки в программе

Рисунок
28. Значения переменных после выполнения
операции b=b+2

С помощью чего выявляются логические ошибки в программе

Рисунок
29. Значения переменных после выполнения
операции S=(S*a)+(S/b)

С помощью чего выявляются логические ошибки в программе

Рисунок
30. Значения переменных после выполнения
операции i++

С помощью чего выявляются логические ошибки в программе

Рисунок
31. Значения переменных после прохождения
цикла

С помощью чего выявляются логические ошибки в программе

Рисунок 32. Вывод
итогового значения на экран

Отладка программы — один их самых сложных этапов разработки программного обеспечения.

9.1. Классификация ошибок

Отладка — это процесс локализации и исправления ошибок, обнаруженных при тестировании программного обеспечения. Локализацией называют процесс определения оператора программы, выполнение которого вызвало нарушение нормального вычислительного процесса. Для исправления ошибки необходимо определить ее причину, т. е. определить оператор или фрагмент, содержащие ошибку. Причины ошибок могут быть как очевидны, так и очень глубоко скрыты.

В соответствии с этапом обработки, на котором проявляются ошибки, различают (рис. 9.1):

синтаксические ошибки — ошибки, фиксируемые компилятором (транслятором, интерпретатором) при выполнении синтаксического и частично семантического анализа программы;

ошибки компоновки — ошибки, обнаруженные компоновщиком (редактором связей) при объединении модулей программы;

ошибки выполнения — ошибки, обнаруженные операционной системой, аппаратными средствами или пользователем при выполнении программы.

С помощью чего выявляются логические ошибки в программе

Рис. 9.1. Классификация ошибок по этапу обработки программы

Синтаксические ошибки относят к группе самых простых, так как синтаксис языка, как правило, строго формализован, и ошибки сопровождаются развернутым комментарием с указанием ее местоположения. Определение причин таких ошибок, как правило, труда не составляет, и даже при нечетком знании правил языка за несколько прогонов удается удалить все ошибки данного типа.

Следует иметь в виду, что чем лучше формализованы правила синтаксиса языка, тем больше ошибок из общего количества может обнаружить компилятор и, соответственно, меньше ошибок будет обнаруживаться на следующих этапах. В связи с этим говорят о языках программирования с защищенным синтаксисом и с незащищенным синтаксисом. К первым, безусловно, можно отнести Pascal, ко вторым — С со всеми его модификациями.

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

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

• появление сообщения об ошибке, зафиксированной схемами контроля выполнения машинных команд,

• появление сообщения об ошибке, обнаруженной операционной системой,

• «зависание» компьютера,

• несовпадение полученных результатов с ожидаемыми.

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

• неверное определение исходных данных,

• логические ошибки,

• накопление погрешностей результатов вычислений.

Неверное определение исходных данных происходит, если возникают любые ошибки при выполнении операций ввода-вывода.

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

• ошибки некорректного использования переменных,

• ошибки вычислений,

• ошибки межмодульного интерфейса,

• другие ошибки кодирования.

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

9.2. Методы отладки программного обеспечения

Большинство ошибок можно обнаружить по косвенным признакам посредством тщательного анализа текстов программ и результатов тестирования без получения дополнительной информации. При этом используют различные методы:

Читать также:  ТОП-10 бесплатных программ для отслеживания багов

• ручного тестирования;

• обратного прослеживания.

Метод ручного тестирования.

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

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

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

Самый ответственный этап — выявление симптомов ошибки. Организуя данные об ошибке, целесообразно записать все, что известно о ее проявлениях, причем фиксируют, как ситуации, в которых фрагмент с ошибкой выполняется нормально, так и ситуации, в которых ошибка проявляется. Если в результате изучения данных никаких гипотез не появляется, то необходима дополнительная информация об ошибке. Дополнительную информацию можно получить, например, в результате выполнения схожих тестов.

В процессе доказательства пытаются выяснить, все ли проявления ошибки объясняет данная гипотеза, если не все, то либо гипотеза не верна, либо ошибок несколько.

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

Метод обратного прослеживания.

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

9.3. Методы и средства получения дополнительной информации

Для получения дополнительной информации об ошибке можно выполнить добавочные тесты или использовать специальные методы и средства

• отладочный вывод,

• интегрированные средства отладки,

• независимые отладчики.

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

Данный метод не очень эффективен и в настоящее время практически не используется.

Интегрированные средства отладки.

Большинство современных сред программирования (Delphi, Builder C++, Visual Studio и т. д.) включают средства отладки, которые обеспечивают максимально эффективную отладку. Они позволяют:

• выполнять программу по шагам, причем как с заходом в подпрограммы, так и выполняя их целиком,

• предусматривать точки останова,

• выполнять программу до оператора указанного курсором и т.п..

Отладка с использованием независимых отладчиков.

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

9.4. Общая методика отладки программного обеспечения

Суммируя все сказанное выше, можно предложить следующую методику отладки программного обеспечения, написанного на универсальных языках программирования для выполнения в операционных системах MS DOS и Win32:

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

Если ошибка не найдена или система просто «зависла», переходят ко второму этапу.

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

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

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

4 этап — исправление ошибки — внесение соответствующих изменений во все операторы, совместное выполнение которых привело к ошибке.

5 этап — повторное тестирование — повторение всех тестов с начала, так как при исправлении обнаруженных ошибок часто вносят в программу новые.

Отладка логических ошибок

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

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

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

Тесты
составляются по схеме алгоритма до
программирования,
так как составление тестов помогает
выявить многие ошибки в алгоритмизации.

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

Для
локализации места ошибки рекомендуется
поступать следующим образом. В окне
Редактора Кода установите курсор в
строке перед подозрительным участком
и нажмите клавишу F4 (выполнить до
курсора). Выполнение приложения будет
остановлено на той строке модуля, в
которой был установлен курсор. Текущее
значение любой переменной можно увидеть,
если накрыть курсором идентификатор
переменной на 1-2 сек. Нажимая клавишу
F8 (пошаговое выполнение), можно построчно
выполнять программу, контролируя
содержимое переменных и правильность
вычислений.

Соседние файлы в папке лекции

Отладка синтаксических ошибок

Синтаксические
ошибки состоят в нарушении формальных
правил использования операторов. Эти
ошибки появляются в результате
недостаточного знания разработчиком
языка программирования и невнимательности
при наборе операторов на экране дисплея.

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

  • компилятор
    распознает не
    все ошибки;
  • некоторые
    ошибки могут повлечь за собой то, что
    правильные операторы будут восприниматься
    компилятором как ошибочные, и наоборот
    – ошибочные операторы компилятор
    воспримет как верные;
  • ошибка
    в одном месте модуля может повлечь за
    собой серию диагностических сообщений
    компилятора в других местах модуля;
  • из-за некоторых
    ошибок компиляция модуля может вообще
    прекращаться и проверка последующих
    операторов не производится.

Информация
обо всех ошибках, найденных в модуле,
выводится в специальное окно, которое
появляется в нижней части экрана. Каждая
строка этого окна содержит имя файла,
номер строки, в которой обнаружена
ошибка и характер ошибки. Если дважды
щелкнуть “мышью” на строке с описанием
ошибки, курсор установится в той строке
модуля, где обнаружена ошибка. Следует
исправлять ошибки последовательно,
сверху вниз и после исправления каждой
ошибки компилировать программу заново.
С целью сокращения времени компиляции
рекомендуется осуществлять проверку
наличия ошибок в режимах Syntax
Check
и Compile
меню Project.
Для получения более полной информации
о характере ошибки можно обратится к
HELP
нажатием клавиши F1.

Отладка
синтаксиса считается завершенной,
когда после очередной компиляции в
режиме Build
All
меню Project
отсутствуют диагностические сообщения
об ошибках.

Добавить комментарий

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