Как найти ошибку в турбо паскале

Содержание

Автор: volvo877 (он же и volvo71)

Ссылка на оригинал статьи

(не хватает картинок из статьи)

Каждый программист знает, что программу надо не только написать, иначе говоря –
«заставить работать», а еще и отладить, т.е. заставить ее работать правильно…
Для того, чтобы делать это быстро и эффективно, желательно научиться
пользоваться встроенными в IDE средствами отладки программ…

Интегрированная интерактивная среда разработки программ Borland Pascal (IDE)
включает в себя ряд средств, облегчающих разработку программ: автоматическое
управление проектами, средств обеспечения модульной структуры программы,
быструю компиляцию и простые в использовании оверлеи. Но, несмотря на все это,
Ваша программа все равно может содержать ошибки, что не позволит ей корректно
работать.

IDE для DOS Borland Pascal предоставляет вам инструментальные средства для
отладки программ, то есть поиска и исправления ошибок. В этой статье
описываются инструментальные средства и процедуры отладки программы в
интегрированной среде Борланд Паскаль (большинство описанных возможностей
применимо также к IDE FreePascal-я).

Существует три основных типа ошибок:

• Ошибки этапа компиляции

• Ошибки этапа выполнения

• Логические ошибки

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

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

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

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

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

Run-time error ## at seg:ofs

Если Вы выполняете программу из IDE, она автоматически находит оператор,
вызвавший ошибку (как и в случае синтаксических ошибок). Если же программа выполняется вне IDE (EXE-файл запускается из командной строки или файлового менеджера ОС), то вы можете запустить IDE и, чтобы найти вызвавший ошибку оператор, использовать команду Search → Find Error, которая дает вам адрес сегмента и смещения (seg:ofs).

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

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

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

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

• Выполнять инструкции по шагам

• Трассировать инструкции

• Выполнять программу до заданной точки

• Находить определенную точку

• Выполнять сброс программы

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

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

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

Выполнение по шагам – это простейший способ выполнения программы по
элементарным фрагментам. Выбор команды Run → Step Over или нажатие клавиши F8 вызывает выполнение отладчиком всего кода в операторе, указанном строкой выполнения, включая любые вызываемые на ней процедуры или функции, пока управление не вернется обратно к вам. После этого строка выполнения указывает следующий выполняемый оператор.

Возьмем, например, следующую программу:

program StepTest;
 
  function Negate(X: Integer): Integer;
  begin
    Negate := -X;
  end;
 
var
  I: Integer;
begin
  for I := 1 to 10 do Writeln(Negate(I));
end.

Если в окне редактирования Вы выведете StepTest и нажмете клавишу F8, то строка выполнения перемещается на оператор begin в начале основного цикла, поскольку это первое, что выполняется в программе. Второе нажатие клавиши F8 выполняет begin и перемещает строку выполнения вниз до оператора for на следующей строке.

После этого нажатие F8 вызывает выполнение всего цикла for; на экран
пользователя выводятся числа от -1 до -10, а строка выполнения перемещается к end.

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

begin
  for I := 1 to 10 do
    WriteLn(Negate(I));
end.

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

Трассировка программы во многом аналогична ее выполнению по шагам. Единственное исключение состоит в том, что когда встречается оператор вызова процедуры/функции, при трассировке эти процедуры и функции также выполняются по шагам, а при простом выполнении по шагам управление возвращается вам после завершения выполнения подпрограммы.

Например, чтобы выполнить трассировку кода в вышеприведенном примере, загрузите файл, затем выберите команду Run → Trace Into или нажмите клавишу F7. Когда Вы в первый раз делаете это, управление перемещается на оператор begin основной программы. Повторное нажатие F7 снова перемещает строку управления на оператор for. После этого нажатие клавиши F7 трассирует вызов функции Negate – строка выполнения перемещается на оператор begin в блоке функции. Если Вы продолжаете нажимать F7, строка выполнения перемещается по функции, а затем, когда Вы дойдете до оператора end, возвращается к оператору вызова.

Формат программы влияет на поведение строки выполнения при трассировке, хотя и не в такой степени как при пошаговом выполнении. Если код сформатирован как в первоначальном варианте приведенного выше примера, то трассировка оператора for приводит к выполнению 10 раз функции Negate. Если вы разобьете оператор for на две строки, то трассировка оператора end функции возвращает строку выполнения: ту строку основной программы, которая будет выполняться следующей. Первые девять раз это снова будет вызов функции. В десятый раз строка выполнения перемещается на оператор end программы.

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

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

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

Чтобы задать в программе точку, до которой она должна выполняться, а затем остановиться, используйте команду Run → GoTo Cursor или клавишу F4. (Этим вы сообщите отладчику, что не хотите выполнять программу по шагам, пока не достигнете заданной точки.) Установите курсор на той строке, где вы хотите возобновить управление отладкой, затем нажмите клавишу F4. Заметим, что Вы можете сделать это как в начале сеанса отладки, так и когда уже выполните часть программы по шагам или протрассируете.

Внимание: С использованием этой команды связана одна особенность: если Вы хотите, чтобы программа выполнилась до определенной строки, и устанавливаете курсор внутри модуля (Unit), то этого не произойдет, Вы просто получите ошибку Cannot Run a Unit , и этим все закончится, т.к. IDE понимает это действие, как приказ запустить модуль, чего делать нельзя. Требуется объяснить IDE, чего Вы от нее хотите примерно так: «Запусти основную программу, и только потом выполни все, до текущего положения курсора». Для этого надо зайти в меню Compile → Primary File, указать системе основной файл (НЕ модуль) Вашего приложения, и
только после этого установить курсор внутрь модуля, и нажать F4…

Казалось бы, что поменялось? А вот что: теперь IDE точно знает – основным
файлом приложения является тот, который был установлен, как Primary File,
следовательно, совершенно нет необходимости запускать МОДУЛЬ, достаточно
запустить основной файл, и остановиться тогда, когда выполнение дойдет до
нужной строки в модуле.

Выполнение программы по шагам или ее трассировка могут помочь Вам найти ошибки в алгоритме программы, но обычно желательно также знать, что происходит на каждом шаге со значениями отдельных переменных. Можно, конечно, по-старинке добавлять в необходимые места программы оператор WriteLn, который распечатает значение контролируемой переменной (а иногда просто нет другого выбора, например, при компиляции крупных проектов на Турбо Паскале возникает необходимость вообще отказаться от IDE, и пользоваться автономной версией компилятора – TPC – запускаемой из командной строки), но если уж есть возможность пользоваться средой программирования – то лучше использовать для контроля за переменными одно из специальных средств IDE: окно Watches (Просмотр) или диалоговое окно Evaluate and Modify (Вычисление и модификация).

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

Элементы выражений отладчика

┌────────────────┬────────────────────────────────────────────────────┐
│Элемент         │Допустимые значения                                 │
│выражения       │                                                    │
├────────────────┼────────────────────────────────────────────────────┤
│                │Все допустимые типы: Boolean, Byte, Char,           │
│Константы       │перечислимый тип, Integer, Longint, Real, Shortint, │
│                │Word и строковый тип.                               │
├────────────────┼────────────────────────────────────────────────────┤
│Переменные      │Все типы, включая типы, определенные пользователем. │
├────────────────┼────────────────────────────────────────────────────┤
│   целочисленный│Любое целочисленное выражение с переменными         │
│тип             │границами диапазона.                                │
├────────────────┼────────────────────────────────────────────────────┤
│   тип с        │Любые выражения с плавающей точкой или целочисленные│
│плавающей точкой│выражения; лишние значащие цифры отбрасываются.     │
├────────────────┼────────────────────────────────────────────────────┤
│                │Любое символьное выражение, включая печатаемые      │
│   символьный   │символы в одинарных кавычках, целочисленные         │
│тип             │выражения, тип которых приведен к типу Char, и      │
│                │контанты ASCII (#xx).                               │
├────────────────┼────────────────────────────────────────────────────┤
│   булевский тип│True, False и все булевские выражения.              │
├────────────────┼────────────────────────────────────────────────────┤
│   перечислимый │Любые совместимые перечислимые константы или        │
│тип             │целочисленные выражения в рамках диапазона, тип     │
│                │которых приведен к совместимому перечислимому типу. │
├────────────────┼────────────────────────────────────────────────────┤
│                │Любые совместимые указатели или выражения с         │
│   указатель    │приведенными к ним типами; функция Ptr с            │
│                │соответствующим параметрами.                        │
├────────────────┼────────────────────────────────────────────────────┤
│                │Любая строковая константа (текст в одинарных        │
│   строковый тип│кавычках); строковые переменные; строковые          │
│                │выражения, состоящие из конкатенированных строковых │
│                │констант и переменных.                              │
├────────────────┼────────────────────────────────────────────────────┤
│                │Любая множественная константа; любое выражение,     │
│   множество    │совместимое с множественным типом, в котором        │
│                │используются операции +, - и *.                     │
├────────────────┼────────────────────────────────────────────────────┤
│Приведение типа │Соблюдаются стандартные правила Паскаля.            │
├────────────────┼────────────────────────────────────────────────────┤
│Операции        │Все операции Borland Pascal.                        │
├────────────────┼────────────────────────────────────────────────────┤
│Встроенные      │Все функции, допустимые в выражениях-константах.    │
│функции         │                                                    │
├────────────────┼────────────────────────────────────────────────────┤
│Массивы         │Массивы Borland Pascal - Mem, MemL, MemW.           │
└────────────────┴────────────────────────────────────────────────────┘

Вначале это окно нужно отобразить на экране. Делается это выбором пункта
меню Debug → Watch. На экране появится пустое окно с соответствующим заголовком.

Теперь запускаем программу в пошаговом режиме (нажатием клавиши F7, или
выбором меню «Run → Trace Into»), в редакторе устанавливаем курсор на
название переменной, за которой будем «следить», и жмем Ctrl+F7 (или меню
«Debug → Add Watch…») и подтверждаем выбор нажатием «Ok»… Всё…
Переменная добавлена в окно Watches, и можно наблюдать за ее значением на Watch каждом шаге выполнения программы…

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

Например, после выполнения выделенной строки

i := 15;

значение переменной i будет уже равно не 0, а 15…

В окне Watches могут отображаться любые типы констант/переменных, объявленных в программе. Например, если описан массив …

const
  arr: array[1 .. 10] of integer = (
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10
  );

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

Кроме массивов и переменных встроенных типов возможно просматривать Просмотр также и записи (либо в простом формате – только имя переменной, либо в записи специальном – с добавлением спецификатора R.

Все возможные спецификаторы перечислены в таблице (перед любым спецификатором можно указать количество повторений, а если не нужно преобразовывать тип переменной, то сам спецификатор можно не указывать, чем я уже пользовался выше, при выводе части массива arr):

┌──────┬─────────────┬────────────────────────────────────────────────────────┐
│      │Тип, на      │                                                        │
│Символ│который он   │Функция                                                 │
│      │влияет       │                                                        │
├──────┼─────────────┼────────────────────────────────────────────────────────┤
│$, H  │целочисленные│Шестнадцатиричный. Выводит целочисленные значения с     │
│или X │типы         │префиксом $, включая те, которые содержатся в структуре │
│      │             │данных.                                                 │
├──────┼─────────────┼────────────────────────────────────────────────────────┤
│      │Char,        │Символьный. Выводит специальные символы для кодов ASCII │
│C     │строковые    │0..31. По умолчанию такие символы выводятся в виде      │
│      │типы         │значений #xx.                                           │
├──────┼─────────────┼────────────────────────────────────────────────────────┤
│      │целочисленные│Десятичный. Выводят целочисленные значения в десятичном │
│D     │типы         │виде (включая те, которые содержатся в структурах       │
│      │             │данных).                                                │
├──────┼─────────────┼────────────────────────────────────────────────────────┤
│Fn    │с плавающей  │С плавающей точкой. Выводит n значащих цифр, где n лежит│
│      │точкой       │в диапазоне 2..18 (по умолчанию - 11).                  │
├──────┼─────────────┼────────────────────────────────────────────────────────┤
│      │             │Дамп памяти. Выводит n байт памяти, начиная с адреса,   │
│nM    │все          │указываемого выражением. Если n не задано, то по        │
│      │             │умолчанию оно равно значению размера в байтах типа      │
│      │             │переменной.                                             │
├──────┼─────────────┼────────────────────────────────────────────────────────┤
│P     │указатели    │Указатель. Выводит указатели в формате сегм:смещ (а не  │
│      │             │Ptr(сегм:смещ), как это делается по умолчанию.          │
├──────┼─────────────┼────────────────────────────────────────────────────────┤
│R     │записи,      │Запись. Выводит имена полей, например, (X:1;Y:10; Z:5)  │
│      │объекты      │вместо (1, 10,5).                                       │
├──────┼─────────────┼────────────────────────────────────────────────────────┤
│      │             │Строки. Выводит символы ASCII 0..31 в виде #xx.         │
│S     │Char, строки │Использует только для модификации дампов памяти (см.    │
│      │             │выше nM).                                               │
└──────┴─────────────┴────────────────────────────────────────────────────────┘

Чтобы вычислить выражение, выбираем команду Debug → Evaluate/Modify или нажимаем клавиши Ctrl+F4. Отладчик выводит диалоговое окно Evaluate and Modify (Вычисление и модификация). Здесь (в поле ввода Expression) можно занести любое допустимое выражение , или выбрать его из списка ранее вычисленных при помощи этого же диалога выражений и отредактировать.

После нажатия на Enter или щелчка мышью на кнопке Evaluate (Вычислить), текущее значение выражения будет показано в поле Result (Результат).

Примечание: если в поле Expression введено выражение, которое не может быть вычислено интегрированной средой, то в поле Result появится вот такая надпись: «Cannot evaluate this expression».

Кроме этого, во время отладки с помощью диалогового окна Evaluate and Modify существует возможность поменять значение переменной на любое другое, чтобы проверить работу программы с другим, вновь присвоенным значением переменной. Для этого нужно установить курсор на имени переменной, и выбрать в меню Debug → Evaluate/Modify… (или просто нажать Ctrl+F4)…

В появившемся окне в поле Expression (Выражение) достаточно ввести имя переменной (или ничего не делать, если имя уже введено), и нажать кнопку Evaluate… Текущее значение выбранной переменной будет отображено в поле Result. Если оно же отображается и в поле New Value, это значит, что у Вас есть возможность прямо сейчас поменять это значение на любое другое (разумеется, совместимое по присваиванию с типом выбранной переменной; присваивать строке целому числу Вам никто не позволит, также, как и, например, записать в целочисленную переменную значение 3.14159), и применить новое значение переменной, не перезапуская программу…

Например, допустим, что программа имеет вид:

var
  i: integer;
begin
  for i := 1 to 20 do
    writeln(i);
  readln;    
end.

, и Вам захотелось попасть в точку, где распечатывается значение i = 20 (желание далеко не самое сумасшедшее, представьте, например, что вместо простого распечатывания значения i там будет вызов какой-нибудь функции, которую надо прогнать пошагово при определенном значении i, да еще и функция может быть длинной и долго выполняться), но не очень хочется нажимать F7 почти 20 раз и приходить в нужную точку «естественным путем». Что делаем? А вот что:

Добавляем значение i в окно Watches, начинаем выполнять программу пошагово (F7)… Я остановился, когда значение i было равно трем, хотя это же самое можно было сделать и сразу после входа в цикл, то есть как только i стало равно единице.

Теперь ставим курсор под название переменной i и жмем Ctrl+F4 для вызова нужного нам окна… Состояние экрана, которое должно получиться, видно на скриншоте…

Переходим в поле New Value (как я говорил, если в нем записано текущее значение переменной, то нам будет позволено его сменить), печатаем в нем значение 20, и жмем на «Modify»…

Как видим, значение i в Watches тоже поменялось на 20, теперь спокойно закрываем окно «Evaluate and Modify» (кнопкой Cancel), и продожлжаем выполнять программу пошагово…

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

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

Да и не нужно этого держать в голове. Для этого существует такое средство, как «Call Stack» (вызывается из меню Debug → Call Stack или просто Ctrl+F3). Например, пусть наша программа имеет вид:

function fact(n: longint): longint;
begin
  if n = 0 then fact := 1
  else fact := n * fact(n - 1);
end;
 
function b(n: longint): integer;
begin
  b := 2 * fact(n);
end;
 
begin
  writeln( b(10) );
end.

Если начать выполнять ее пошагово, очень скоро можно запутаться в том, что именно сейчас выполняется (факториал какого числа вычисляется в данный момент, к примеру), и что еще осталось НЕзавершенным. А если программа будет в 10 раз длиннее, и будет содержать не 2, а 10 процедур/функций? В таком случае достаточно вызвать окно Call Stack (способ вызова – выше), и посмотреть, что именно в данный момент выполняется (то есть находится на першине стека вызовов), и что еще выполняться будет (находится ниже в списке), вплоть до Program, обозначающего, самый нижний уровень – основную программу…

Вот, например, в данном случае: выполняется функция вычисление факториала 8, которая вызвана из нижестоящей в списке функции вычисления факториала 9, которая в свою очередь… Ну, дальше все понятно… При продолжении пошагового выполнения этой программы в окно Call Stack будут добавляться новые и новые вызовы Fact (7), Fact(6), … до Fact(0); потом рекурсия начнет раскручиваться обратно…

Кстати, Call Stack – незаменимый помощник именно при работе с рекурсивными подпрограммами, поскольку дает возможность контролировать последовательность вызовов рекурсивной функции, и на ранней стадии определить, например, бесконечную рекурсию…
Например, здесь – совершенно очевидно, что рекурсивная функция оформлена неверно (отсутствует ветка Else), сразу после того, как в окне Call Stack появились вызовы f (-1) и f(-2)…

Еще одно полезное применение окна Call Stack – если вы случайно начали трассировку кода, который хотели бы выполнить за один шаг. В стеке вызовов вы можете найти тот вызов, который начали трассировать по ошибке, затем выбрать команду Run to Cursor, чтобы выполнить за один шаг остальную часть вызова.

Кроме всех вышеперечисленных возможностей, значительно облегчающих жизнь программисту, в IDE Паскаля встроено еще одно средство, очень мощное и эффективное (при правильном использовании)… Это – работа с точками останова программы (BreakPoints).

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

Допустим, есть следующая программа:

const
  parameter = 10;
 
function f(x: integer): integer;
begin
  f := 10 * parameter - sqr(x);
end;
 
var
  i, j: integer;
  arr: array[1 .. 20] of real;
begin
  for i := 1 to 20 do begin
    j := f(i);
    arr[i] := (15 * j / parameter) + i / j - 8;
  end;
  { ... }
end.

(не обольщайтесь, программа может быть не в 17, а в 1700 строк длиной, и функция f может быть гораздо более сложной, так же как и способ ее вызова)…

Естественно, запустив эту программу, получаем:

Runtime error 200 at 0006:0004.

, из чего заключаем, что где-то в программе происходит деление на 0. Ну, где
оно происходит, понятно. А вот на какой итерации? Чему равно i, при котором
происходит эта ошибка? Можно, конечно, воспользоваться старым и проверенным
способом, и сделать так:

const
  parameter = 10;
 
function f(x: integer): integer;
begin
  f := 10 * parameter - sqr(x);
end;
 
var
  i, j: integer;
  arr: array[1 .. 20] of real;
begin
  for i := 1 to 20 do begin
    j := f(i);
    writeln('j = ', j);
    arr[i] := (15 * j / parameter) + i / j - 8;
  end;
  { ... }
end.

, после чего нам будут распечатаны все значения j, для которых программа отработала нормально, и еще одно, при котором как раз и произошло «Деление на Ноль». Но для этого нужно вносить изменения в программу. А можно обойтись без её изменений… Используя точку останова…

Для этого проделаем следующее… Во-первых, добавим переменную i в список Watches, так как нам нужно найти именно «при каком i программа вылетает».

Далее – установим курсор на той строке программы, где происходит деление, и выберем в меню пункт «Debug → Add Breakpoint…» Экран примет вид, показанный на снимке справа.

Примечание: строка, на которую устанавливается BreakPoint, должна содержать выполняемый код и не может быть комментарием, описанием или пустой строкой…

В поле Condition внесем условие, при котором следует остановить программу (условие вводится так же как и при использовании условных операторов в программе, только Условный If здесь присутствовать не должно), и подтверждаем установку BreakPoint-а нажатием кнопки «Ok»:

Строка, в которой установлен хотя бы один BreakPoint (а устанавливать можно несколько точек останова для программы, причем даже на одной строке, но с разными условиями, может быть установлено более одного BreakPoint-а) меняет цвет на красный…

Если теперь запустить программу (обычным способом – через Ctrl+F9, или пошагово, не имеет значения), то как только значение j в Условный выделенной строке станет равным 0, прогон программы будет приостановлен с выдачей вот такого сообщения:

Как видим (в окне Watches), происходит это при i = 10… Что и требовалось
определить…

Чтобы просмотреть, какие BreakPoint-ы были установлены в программе, достаточно зайти в меню «Debug → BreakPoints», и будет выведен список всех точек останова для данной программы:

Нажатием на «Clear All» можно удалить все точки останова сразу, «Delete» удалит только подсвеченный BreakPoint, а «Edit»-ом можно отредактировать текущий (подсвеченный) BreakPoint – подкорректировать условие, поменять номер строки, в которой должна производиться проверка, изменить счетчик числа проходов (задание для точки останова счетчика проходов сообщает отладчику, что останавливать программу нужно не при каждом достижении точки останова, а только на n-ый раз. То есть, если счетчик проходов равен 3, то отладчик останавливает программу только при третьем достижении данной точки останова) и т.д.

страницы: 1 2 3

Содержание

• Содержание
  • Поиск и исправление ошибок
  • Правила составления тестов
• Оптимизация программ
• Примечания

Поиск и исправление ошибок

При поиске ошибок большим подспорьем является возможность пошагового выполнения (трассировки) программы с параллельным отслеживанием того, как меняются в ходе неё значения переменных. В среде Turbo Pascal для этого имеются следующие инструменты:

• Нажатие клавиши F4 выполнит программу до той строки, на которой установлен курсор, затем приостановит выполнение.
• Нажатие клавиши F7 или F8 позволяет выполнять программу пошагово: по одному оператору (различие между этими функциями состоит в том, производится или нет трассировка текстов подпрограмм).
• Использование окна отладочной выдачи Отладка | Наблюдения (в английской версии Debug | Watch) позволяет в процессе выполнения программы следить за тем, как изменяются значения переменных (нажатие клавиши Insert добавляет в это окно новую переменную).

Более подробно эти возможности описаны в руководствe по среде Turbo Pascal.

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

Совет 16. Пользуйтесь всеми доступными инструментами отладки.

Совет 17. На всех ключевых участках, а также на границах логически самостоятельных блоков вставляйте в программу отладочные операторы печати, которые позволят вам проследить изменение состояния основных переменных. Эта процедура не всегда может быть заменена просмотром изменений, который можно осуществить с помощью окна Watch. Зачастую бывает необходимо иметь перед собой для сравнения результаты нескольких последовательных итераций, либо нужно видеть одновременно первые и последние результаты, либо в процессе прогонки возвращаться по списку выдачи назад, к предыдущим результатам. Ничего этого параллельный просмотр в Watch сделать не позволяет.

Если отладочная выдача настолько объёмна, что не помещается целиком на экран, её приходится производить в файл.

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

Самый легкий случай, — когда из–за опечатки полностью меняется вид вывода. Например, правильный оператор WriteLn(a + 1) должен выдать число, если же вместо числа на экране вдруг появляется слово FALSE, то это явный признак того, что произошла опечатка и выдаётся результат сравнения переменной а с единицей: WriteLn(a = 1).

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

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

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

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

Правила составления тестов

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

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

И здесь существуют следующие правила.

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

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

Из двух предыдущих абзацев вытекает очень важный вывод: нельзя строить тесты при помощи генератора случайных чисел. Конечно, вы можете случайным образом составить входные данные, но как быть с правильным ответом? Откуда его взять, если вы сами понятия не имеете, что там подаётся на вход?

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

Правило 3. Не ограничивайтесь только похожими тестами.

Все тесты можно разделить на три группы: регулярные, граничные и критические. Например, при заданных ограничениях на параметр 0 <= x <= 100 регулярными будут все тесты, где 1 <= x <= 99; граничными, где х = 0 и х = 100; остальные — критическими. Если ваша программа правильно работает для пяти–шести тестов из какой–либо группы, можно предположить, что она выдаст правильный результат и для всех остальных тестов из этой группы.

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

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

Правило 4. Исправления, вносимые в программу, могут повлиять на результаты нескольких тестов.

После того, как вы нашли и исправили ошибку, вновь выполните программу на всех тех тестах, которые раньше не были успешными (то есть, выдавали правильные ответы) — а вдруг найдётся новая ошибка?

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

Оптимизация программ

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

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

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

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

Например, ясно, что из двух эквивалентных кусков

и

второй является и более быстрым (особенно если b = 10000), и более компактным, чем первый.

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

Успехов вам в написании красивых и полезных программ!

страницы: 1 2 3

Примечания

b:=n; writeln ('b=',b);
n:=trunk(a);writeln ('trunk'(3.6)=',n);

11