Как найти ошибки в коде паскаль

![введите сюда описание изображения]1

с шестой строки выдает ошибку, хотя пишу с учебника, в чем проблема?
Паскаль абсNET. Использование вещественных числе с целыми.

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

Anton Shchyrov's user avatar

Anton Shchyrov

32.9k2 золотых знака29 серебряных знаков59 бронзовых знаков

задан 1 дек 2016 в 13:10

GProst's user avatar

11

После третьей строки должен быть begin, на 7 строке второй апостроф – лишний.

A K's user avatar

A K

28.4k19 золотых знаков54 серебряных знака129 бронзовых знаков

ответ дан 1 дек 2016 в 13:21

Anton Shchyrov's user avatar

Anton ShchyrovAnton Shchyrov

32.9k2 золотых знака29 серебряных знаков59 бронзовых знаков

3

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

  1. Создайте пустую программу
  2. Запустите – запустилось – хорошо, не запустилось ищите ошибку.
  3. Добавляйте по одной строчке из вашего примера и запускайте – таким образом вы увидите какую строку перепечатали неверно!

ответ дан 1 дек 2016 в 13:23

JVic's user avatar

JVicJVic

3,2691 золотой знак15 серебряных знаков35 бронзовых знаков

1

Содержание

Отладка программ в Turbo Pascal

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

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

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

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

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

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

Что такое отладка?

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

Какие существуют виды ошибок?

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

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

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

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

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

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

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

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

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

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

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

Run-time error ## at seg:ofs

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

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

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

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

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

Пошаговый прогон: какая разница между F4, F7 и F8?

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

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

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

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

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

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

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

Что такое шаг?

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

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

Выполнение программы по шагам

Выполнение по шагам – это простейший способ выполнения программы по
элементарным фрагментам. Выбор команды 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,
следовательно, совершенно нет необходимости запускать МОДУЛЬ, достаточно
запустить основной файл, и остановиться тогда, когда выполнение дойдет до
нужной строки в модуле.

Что такое окно Watches и как им пользоваться?

Выполнение программы по шагам или ее трассировка могут помочь Вам найти ошибки в алгоритме программы, но обычно желательно также знать, что происходит на каждом шаге со значениями отдельных переменных. Можно, конечно, по-старинке добавлять в необходимые места программы оператор 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.           │
└────────────────┴────────────────────────────────────────────────────┘

Разберем использование окна Watches

Вначале это окно нужно отобразить на экране. Делается это выбором пункта
меню 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).                                               │
└──────┴─────────────┴────────────────────────────────────────────────────────┘

Окно Evaluate and Modify

Но кроме простого просмотра значений той или иной переменной или выражения,
существует средство, позволяющее вам в любой момент вычислять выражения и
изменять на этапе выполнения значения переменных. Этим средством и является
диалог Evaluate and Modify (Вычисление и модификация).

Вычисление выражений

Чтобы вычислить выражение, выбираем команду 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), и продожлжаем выполнять программу пошагово…

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

Окно Call Stack – что это такое?

В 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, то отладчик останавливает программу только при третьем достижении данной точки останова) и т.д.

Поиск нужного места

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

Повторное выполнение (сброс программы)

В ходе сеанса отладки иногда желательно начать все сначала. Выберите команду Run → Reset Program или нажмите клавиши Ctrl+F2. Это приведет к полному сбросу, так что выполнение по шагам, или трассировка начнется в начале основной программы.

Отслеживание вывода программы

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

Переключение экранов

В любой момент сеанса отладки вы можете выполнять переключение экрана IDE и экрана пользователя. Чтобы вывести экран пользователя, нажмите клавиши Alt+F5. Чтобы вернуться в IDE, нажмите любую клавишу или щелкните «мышью».

Окно Output

IDE для DOS предусматривает для экрана пользователя окно, которое называется окном вывода. Выбрав команду меню Debug → Output, вы можете открыть (вывести на передний план) активное окно, содержащее вывод программы. Настроить размер этого окна можно аналогично окну редактирования.

как в этой программе узнать в какой строке ошибка?

Turbo Pascal



Ученик

(73),
на голосовании



7 лет назад

Голосование за лучший ответ

.

Оракул

(77956)


7 лет назад

Внизу на зеленом фоне Compiler Messages (Сообщения компилятора). Компилятор выдаёт тебе всякие сообщения, в том числе и об ошибках.
В скобочках указан номер строки и номер символа. Когда описываешь переменные надо ставить двоеточие, а не знак присваивания.
И программа должна начинаться со слова
program <название>; (на скрине просто не видно)

Добавил:

Upload

Опубликованный материал нарушает ваши авторские права? Сообщите нам.

Вуз:

Предмет:

Файл:

Pascal.doc

Скачиваний:

26

Добавлен:

12.03.2016

Размер:

3.29 Mб

Скачать

Сообщения
об ошибках.
Ошибки в
программах делятся на те, которые
Паскаль замечает, и на те, что не замечает
и в принципе заметить не может. К первым
относятся все синтаксические погрешности,
например,BIGINвместоBEGIN.
Их Паскаль замечает еще на стадии
компиляции. На стадии выполнения он
замечает такие ошибки, какSqrt(-25),
то есть квадратный корень из ‑25. Но
вот, если вы, желая возвести числоa
в куб, вместоa*a*aпишетеa*a,
то этого не заметит ни один язык в мире.

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

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

Вот наиболее
типичные для начинающих сообщения об
ошибках того и другого рода:

Сообщение

Перевод

Вероятная
причина ошибки

Unexpected end of file

Неожиданный
конец файла

Вы забыли
поставить точку после последнего
END.
Или не совпадает количествоbeginи количествоend

“;” expected

Ждал точку с
запятой

Вы забыли
поставить точку с запятой после
предыдущего оператора

“,” expected

Ждал запятую

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

“)” expected

Ждал скобку “)”

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

Unknown identifier

Неизвестное
имя

Вы забыли описать
это имя в разделе описаний

Неправильно
записали стандартное имя, например,
ReedLnвместоReadLn

Type mismatch

Несовпадение
типов

В вашей программе
встречаются примерно такие «сладкие
парочки»: VAR c:String; … c:=1+2илиVAR
h:Integer; … h:=9/7

Duplicate identifier

Дубль имени

Одно и то же имя
описано два раза. Например,
VAR a, c, a :String;

Syntax error

Синтаксическая
ошибка

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

BEGIN
expected

Ждал BEGIN

Возможно, не
совпадает количество beginи количествоend

END
expected

Ждал
END

Возможно, не
совпадает количество beginи количествоend

String
constant exeeds line

Строковая
константа превышает допустимую длину

Вы забыли закрыть
кавычки в строковой константе

Line too long

Строчка слишком
длинна

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

Disk full

Диск заполнен

На вашем диске
не осталось места. Надо что-то стереть

Lower bound greater than
upper bound

Нижняя граница
диапазона больше верхней

Например, вы
вместо array[2..5]написалиarray[5..2].

Invalid floating point
operation

Неправильная
операция с вещественным результатом

Sqrt(-25)илиa/0или что-нибудь в этом роде

Ordinal expression
expected

Ждал выражение
порядкового типа

Например, вы
вместо for
i:=1
to
8
написали
for
i:=1
to
8.5

Error in expression

Ошибка в выражении

Например, вы
вместо k:=а*8написалиk:=а**8

Range check error

Ошибка проверки
диапазона

Переменная
в процессе выполнения программы
вышла за пределы допустимого диапазона,
как например, в 1.9

Constant out of range

Константа не в
диапазоне

Величина
константы в программе превосходит
допустимый диапазон

Invalid numeric format

Неправильный
числовой формат

Если, например,
вы по оператору ReadLn(k)в программеVAR
k:Integer; …. ReadLn(k) …
пытаетесь
ввести число 25.3

Более подробное
описание некоторых ошибок вы найдете
в 0.3.

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

expected
ждал

identifier
имя

invalid
неправильный

operation операция

error
ошибка

variable переменная

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

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

  • #
  • #
  • #
  • #
  • #
  • #
  • #
  • #
  • #
  • #
  • #

Have a bit of a weird one and hopefully someone can help out.

The company I work for is doing an ad and we are looking for a Pascal programmer and we thought we’d incorporate some Pascal code into the ad itself. The only problem is we do not have any knowledge regarding Pascal. So after a little research the code we have come up with is:

Begin
 Write('Enter in Name:');
 readln(company);
 Write('Enter in Australia:');
 readln(country);
 writeln;{new line}
 writeln;{new line}
 Writeln('Programming specialists:', 'company' ,'country');
 Readln;
End.

And what we are trying to say is:

The person types in Name
And then types in Australia
And then on the screen appears Programming specialists: Name Australia

So is the syntax correct are we missing anything? like comma’s or semi-colons etc

asked Sep 5, 2010 at 23:46

salted's user avatar

1

It seems fine except for this line:

Writeln('Programming specialists:', 'company' ,'country');

You’re printing the strings “company” and “country”, but I assume you actually want the values entered by the user. So it should be:

Writeln('Programming specialists:', company ,country);

answered Sep 6, 2010 at 0:06

casablanca's user avatar

casablancacasablanca

69.4k7 gold badges132 silver badges150 bronze badges

That seems fine to me. I’m pretty fresh for programming in Pascal – did it in my college course only a couple of months ago. Take into account casablanca’s comment though.

Also, make sure you have the top half of the program correct. Like so:

Program advert; {or any other pertinent name}
Uses crt; {This may be unneeded, but we were taught to always put it in}

Var
company, country: string;

Begin
    Writeln('Enter in name');
     {Writeln or write depends on how you want this to work - write will make the input on the same line (in a terminal) and writeln will make the input on line below}
    Readln(company);
    Write('Enter in Australia');
    Readln(country);
    Writeln;
    Writeln;
    Writeln('Programming specialists: ', company, ' ', country);
    Readln;
End.

In regards to the Readln at the end of the program, you might not need to use it. This essentially ‘pauses’ the program until the user presses the enter key. I noticed that in Windows the command prompt had a habit of closing at the end, making a final readln necessary, but in a Linux terminal, running the program from the terminal, this doesn’t happen. Just a side note for you to consider.

answered Sep 6, 2010 at 0:19

Saladin Akara's user avatar

Saladin AkaraSaladin Akara

2,5086 gold badges30 silver badges50 bronze badges

0

You could test this yourself with Free Pascal.

answered Sep 6, 2010 at 0:03

Jack Kelly's user avatar

Jack KellyJack Kelly

18.2k2 gold badges55 silver badges81 bronze badges

you must remove the ' (single cuotes) character from the company and country variables, try this

var
company,country :string;
Begin
 Write('Enter in Name:');
 readln(company);
 Write('Enter in Australia:');
 readln(country);
 writeln;{new line}
 writeln;{new line}
 Writeln('Programming specialists:', company,' ' ,country);
 Readln;
End.

you can check this free ebook to learn more about the pascal syntax

Marco Cantù’s Essential Pascal

answered Sep 6, 2010 at 0:09

RRUZ's user avatar

RRUZRRUZ

135k19 gold badges356 silver badges483 bronze badges

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