Что такое ошибка времени выполнения паскаль

Неописанная переменная

begin
  S := 1; // Неизвестное имя S
end.

Все используемые переменные должны быть предварительно описаны с помощью ключевого слова var (внутри блока begin/end или, что обычно хуже, в разделе описаний вначале программы).

Отсутствующая ;

begin
  var S: integer 
  S := 1;         // Компилятор здесь скажет: Ожидалась ; — имеется ввиду предыдущая строка!
end.

begin
  var S := 1 
  S := S + 1  // Аналогично: проблема на предыдущей строке, а на текущей нет, потому что после неё идёт end.
end.

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

Несовместимость типов при присваивании

begin
  var S: integer := 1.3; // Нельзя преобразовать тип real к integer
end.

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

Чтобы не ошибаться в подобных простых случаях в Паскале есть следующая краткая форма объявления и инициализации переменной:

begin
  var S := 1.3; // Тип real будет выведен компилятором автоматически
end.

Отсутствие закрывающего апострофа литеральной строки

begin
  var x := 2;   // x получает тип integer
  var y := 3;   // y получает тип integer
  writeln('Результат сложения равен =, x + y); // Не хватает закрывающего апострофа
end.

Закрыть апостроф надо на той же строке, где расположен открывающий апостроф

Ошибки расстановки запятых и апострофов при выводе строк и выражений

begin
  var x := 2;   // x получает тип integer
  var y := 3;   // y получает тип integer
  writeln(x, '+,' y, '=', x+y); // Неверная расстановка запятых и апострофов
end.

Слишком много запятых и апострофов рядом, потому начинающие часто путаются 
Надо уяснить правила:

• запятые разделяют разные элементы вывода
• все, что находится в апострофах, будет выведено на экран без изменений

Ошибка ввода

begin
  var x: integer;
  read(x); // введите блаблабла и посмотрите, что получится
end.

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

Аналогичный фрагмент в более современном и предпочтительном синтаксисе:

begin
  var x := ReadInteger;
end.

Ошибка неинициализированной переменной

begin
  var x: integer;
  // Забыли инициализировать или ввести x
  var r := x * x;  // r получает тип integer
  writeln('Квадрат числа ', x, ' = ', r);
end.

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

Деление на 0

begin
  var x := 0;
  var c := 666 div x; // Здесь происходит деление на 0
end.

Если во время выполнения программа выполнит деление на 0, то она завершится с ошибкой.

Корень из отрицательного числа

begin
  writeln(sqrt(-1)); // Корень из отрицательного числа 
end.

В обычном Паскале возникает ошибка времени выполнения.
В PascalABC.NET выводится NaN — Not a Number

Ссылки

• Программы для начинающих
• Сайт PascalABC.NET: Программы и алгоритмы для начинающих

В программе работает все, кроме удаления записи из файла

Собственно сама ошибка:

строка (254) : Ошибка времени выполнения: Входная строка имела неверный формат.

В строке 254 находится (readln(menu);)

  program Telophonia;

type
  abonent = record
    number:   string[10];                //Номер телефона
    FIO:      string[40];                //ФИО абонента
    adres: record               //Адрес абонента в виде другой записи состоящий из:
    street: string[20];                            //Улица
    house:  string[20];                            //Дом
    flat:   string[20];                            //Квартира
    end;
    date:     string[10];                   //Дата подключения абонента
  end;

var
  abonents: file of abonent;             //Файл содержащий записи об абонентах
  x, t: abonent;                        //Вспомогательная переменная типа записи об абонентах
  menu, ind, cnt: integer;              //Вспомогательные переменные для меню, индексации и счетчика записей в некоторых процедурах
  yn: char;                             //Переменная y/n ответов
  filename: string[25];                 //Имя файла, задаваемое пользователем
  nmbr: string[10];                     //Вспомогательная переменная для номера абонента


//Процедура удаления записи из файла
procedure del(a: file of abonent);
label nachalo,ex;//метка начала и конца процедуры
begin
  nachalo:     //метка начала процедуры
  reset(a);
  write('Введите номер:');
  read(nmbr);
  cnt := 0;       //ведем счет записей из файла, чтобы в дальнейшем обратиться к нужной считанной записи и удалить ее
  repeat     //просматривать файл на совпадение номера абонента
    if eof(a) then    //если дошли до конца и не нашли нужного абонента
    begin
      writeln('Абонента с таким номером не существует!');
      write('Найти по другому номеру? (y/n):');
      readln(yn);
      if yn = 'y' then goto nachalo else goto ex;
    end;
    read(a, t);     //чтение записи из файла
    cnt := cnt + 1;   //увеличиваем счетчик записей на один
  until t.number = nmbr;
  writeln('Найденный абонент:');
  writeln(t.number, ' ', t.FIO, ' ', t.adres.street, ' ', t.adres.house, ' ', t.adres.flat, ' ', t.date);
  writeln;
  writeln('Удалить данные об абоненте? (y/n):');
  readln(yn);
  if yn <> 'y' then goto ex;
  cnt := cnt - 1;
  while not eof(a) do
  begin
    if filesize(a)=cnt+1 then break;
    seek(a, cnt+1); //перевод указателя на следующий элемент
    read(a, t);
    seek(a, cnt);    //перевод указателя на удаляемого абонента
    write(a, t);      //перезапись следующего абонента из файла на место удаляемого
    cnt := cnt + 1;
    seek(a, cnt);   //перевод указателя на следующую за переписанным абонентом
  end;
  seek(a, filesize(a) - 1);   //перевод указателя на последнюю запись в файле
  truncate(a);  //удаление последней записи в файле
  writeln('Данные удалены');
  write('Найти по другому номеру? (y/n):');
  readln(yn);
  if yn = 'y' then goto nachalo;
  ex:    //метка выхода из процедуры
  close(a);
end;

   //Процедура корректировки записи в файле
procedure edit(a: file of abonent);
label nachalo,ex;//метки начала процедуры и выхода из нее
begin
  reset(a);
  nachalo:     //метка начала процедуры
  write('Введите номер абонента:');
  read(nmbr);
  cnt := 0;       //ведем счет записей из файла, чтобы в дальнейшем обратиться к нужной считанной записи и перезаписать ее
  yn:='n';
  while not eof(a) do
  begin
    read(a, t);     //чтение записи из файла
    cnt:= cnt + 1;   //увеличиваем счетчик записей на один
    if t.number = nmbr then break;
  end;
  if eof(a) then    //если дошли до конца и не нашли нужного абонента
  begin
       writeln('Абонента с таким номером не существует!');
       write('Найти по другому номеру? (y/n):');
       readln(yn);
       if yn = 'y' then goto nachalo else goto ex;
  end;
  cnt := cnt - 1;   //возвращаемся к предыдущей записи, чтобы ее изменить
  writeln('Изменить данные об абоненте? (y/n):');
  readln(yn);
  readln(yn);
  if yn <> 'y' then goto ex;
  with x do
  begin
    repeat    //просматривать файл на совпадение номера абонента
      write('Номер абонента = ');
      readln(number);
      reset(a);
      while not eof(a) do
      begin
        read(a, t);    //чтение записи из файла
        if t.number = number then
        begin
          writeln('Абонент с таким номером уже существует!');
          break;        //выходим из цикла while и повторяем сначала
        end;
      end;
    until t.number <> number;
    write('ФИО = ');
    readln(FIO);
    write('Улица = ');
    readln(adres.street);
    write('Дом = ');
    readln(adres.house);
    write('Квартира = ');
    readln(adres.flat);
    write('Дата подключения = ');
    readln(date);
    writeln;
  end;
  writeln('Изменить данные об абоненте? (y/n):');
  readln(yn);
  readln(yn);
  if yn <> 'y' then goto ex;
  seek(a, cnt);
  write(a, x);  //запись переменной в файл
  writeln('Изменения приняты.');
  WriteLn;
  writeln('Найти по другому номеру? (y/n):');
  readln(yn);
  if yn = 'y' then goto nachalo;
  ex:    //метка выхода из процедуры
  close(a);
end;
//Процедура вывода содержимого файла на экран
procedure find(a: file of abonent);
label nachalo;
begin
     nachalo:
     with x do
     begin
          write('Номер абонента = ');
          readln(number);
          reset(a);
          cnt := 0;   //ведем счет удовлетворяющих запросу записей
          while not eof(a) do
           begin
                read(a, t);    //чтение записи из файла
                if t.number = number then
                begin
                     writeln('Найдено:');
                     writeln(number, ' ', FIO, ' ', adres.street, ' ', adres.house, ' ', adres.flat, ' ', date);
                     cnt := cnt + 1;
                     break;
                end;
           end;
      end;
  if cnt=0 then writeln('Не найдено абонента с таким номером.');
  writeln;
  writeln('Найти по другому номеру? (y/n):');
  readln(yn);
  if yn = 'y' then goto nachalo;
  close(a);
end;



begin
  write('Введите имя файла: ');
  readln(filename);
  assign(abonents, filename);
  repeat
    writeln('1: Вывести содержимое');
    writeln('2: Добавить абонента');
    writeln('3: Удалить абонента');
    writeln('4: Изменить данные абонента');
    writeln('5: Найти по номеру');
    writeln('0: Выход');
    write('Выберите действие: ');
    readln(menu);
    writeln;
    case menu of
      1: show(abonents);
      2: add(abonents);
      3: del(abonents);
      4: edit(abonents);
      5: find(abonents);
    end;
  until menu = 0;
end.

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

Ускорьте свой ПК всего за несколько кликов

Загрузите это программное обеспечение сейчас и попрощайтесь с проблемами вашего компьютера. г.

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

<таблица readabilitydatatable = «1»>

<тд>

<тд> <тд>

Время указано в формате UTC

<случаи>

<таблица readabilitydatatable = «1»>

Г. Г-н Сталин
номер 1/4

<тд>

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

<тд>

Тимо Сал
# 2/4

<тд>

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

<р> Если возможно, дайте мне хороший список описаний всех этих веб-страниц с ошибками, или
: скажите мне, где я могу попытаться получить такой последний список.

Транспорт защищен

33)
Какая отличная ошибка, например ошибка чтения first thererrrs 205 и т.д.

149061 19 июля 1998 г. ftp: //garbo.uwasa.fi/pc/link/tsfaqp.zip
tsfaqp.zip Часто задаваемые вопросы, касающиеся опций Turbo Pascal и Timo, подключенных к

Всем как лучше,
timo

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

<тд>

<тд>

Роммерт Дж. Казими
№ 3-4

<тд>

Вычислить ошибку выполнения 005

Цитата:

Ошибка выполнения 5: Доступ к файлу запрещен. Это происходит, когда файл уже проверяется другой школой, например, когда он снова проверяется в Excel.
Однако при ошибке Turbo-7 150 запись на диск выполняется

Цитата:

Контактный документ является справочной функцией почти версии Borland Pascal, обнаруживает
ошибки, запускается, как только пользователь нажимает Shift F1. Если вы не являетесь пользователем Pascal
, обратитесь к поставщику программного обеспечения. Если за надежным программистом нельзя следить, зачем вообще доверять новой программе?

–
Rommert J. Casimir
Тилбургский университет, B435, тел. 31 12 4662016
PO Box 90153, 5000LE Тилбург, Нидерланды
http: // cwis .kub .nl ~ несколько / несколько / BIKA / rc_home.htm

<тд>

<тд>

боюсь шало №4 или четыре

<тд>

Ошибка выполнения в программном обеспечении 005

Цитата:

если вы подразумеваете, что исполняемые файлы написаны на Пасху < br> Пользователь может получить полный формат, используя сообщения об ошибках в некоторых меню
Помощь | Ошибки выполнения

. Перезвони

<тд>

<таблица readabilitydatatable равна «0»>

<тд> <случаи> <тд> <тд>

Введение.

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

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

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

Типы
ошибок.

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

Ошибки
компиляции.

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

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

Если
используется версия командной строки
(TPC.EXE), Turbo Pascal будет выводить ошибочный
оператор, номер строки и сообщение об
ошибке. Затем пользователь может войти
в любой используемый им редактор, найти
заданную строку, исправить ошибку и
перекомпилировать программу. Для
дополнительной информации о сообщениях
об ошибках см. Приложение А в Руководстве
программиста.

Ошибки
времени выполнения.

Другой
тип ошибок — ошибки времени выполнения
программы или семантические ошибки.
Они встречаются, когда пользователь
компилирует синтаксически корректную
программу, которая пытается сделать
что-нибудь запрещенное во время ее
выполнения, например, открывает
несуществующий файл для ввода или
производит деление на 0. В этом случае
Turbo Pascal выводит на экран следующее
сообщение об ошибке: Runtime error ## at seg:ofs
(Ошибка выполнения # в сегменте:смещение)
и останавливает выполнение программы
пользователя.

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

Если
пользователь выполняет программу в
среде MS-DOS, он будет возвращаться в
MS-DOS. Пользователь может загрузить модуль
TURBO.EXE и использовать опции Search/Find error
для локализации позиции ошибки в исходной
программе (убедитесь, что опция Destination
установлена в Disk). Для обнаружения ошибки
пользователь может также использовать
и опцию /F для компилятора командной
строки (TPC.EXE).

(Более
полное объяснение опций командной
строки TPC.EXE приведено в главе 9 «Компилятор
командной строки».)

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

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

Интегрированный
отладчик Turbo Pascal.

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

Интегрированный
отладчик Turbo Pascal имеет все описанные
выше возможности и даже более того. Он
представляет собой встроенную часть
интегрированной усовершенствованной
среды Turbo Pascal (IDE): для использования
предлагаются две основные функции меню
(Run, Debug), а также некоторые клавиши для
команд отладчика. Для дополнительной
информации об IDE горячих клавишах см.
главу 7 «Справочник по IDE» или
справочную информацию о Turbo Pascal.

Что
может делать отладчик.

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

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

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

Обзор
возможностей отладчика:

Трассировка.
F7

Run/Trace
Into Вы можете выполнить одну строку вашей
программы, затем прерваться и посмотреть
на результаты. При вызове процедуры или
функции внутри вашей программы, Вы
можете задать режим выполнения вызова
как одного шага или режим трассировки
этой процедуры или функции строка за
строкой.

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

Переход
на курсор. F4

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

Прерывание.

С
помощью команды Debug/Breakpoints Вы можете
пометить строки в Вашей программе как
точки прерывания. Когда в процессе
выполнения Вашей программы достигается
точка прерывания, выполнение программы
приостанавливается и отображается
исходный текст и курсор останавливается
на строке с точкой прерывания. Затем Вы
можете проверить значения переменных,
начать трассировку или выполнить
программу до другой точки прерывания.
Вы можете подключить условие к точке
прерывания. Вы можете также прерваться
в любой точке Вашей программы, нажав
клавишу Ctrl-Break. Произойдет остановка на
следующей строке исходной программы,
как если бы в этой строке была установлена
точка прерывания.

Наблюдение.

Debug/Watches
Пользователь имеет возможность задавать
для просмотра в окне Watch некоторые
объекты (переменные, структуры данных,
выражения). Просматриваемые данные
меняются, отражая текущие изменения в
программе при пошаговом выполнении.

Вычисление/модификация
Ctrl-F4.

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

Поиск.

Пользователь
может быстро находить объявления
процедур или функций, даже если программа
разбита на несколько модулей (Search/Find
Рrocedure). Во время трассировки Вы можете
быстро вернуться обратно из вызовов
процедур или функций и проверить
параметры каждого вызова (Window/Call Stack).

Подготовка
к использованию отладчика.

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

Прежде,
чем начать отладку программы, Вы должны
задать для компилятора Turbo Pascal инструкцию
по генерации таблицы символов и таблицы
номеров строк этой программы. Таблица
символов представляет собой небольшую
базу данных со всеми используемыми
идентификаторами — константами, типами,
переменными, процедурами и информацией
о номерах строк. Директивы компилятора
$D+ и $L+ делают это по умолчанию; они
соответствуют элементам меню
Options/Compiler/Debug
Information и
Options/Compiler/Local Symbols. Так
же по умолчанию установлена опция
Options/Debugger/Integrated, которая генерирует
отладочную информацию в выполнимом
файле.

Директива
{$D+} генерирует таблицу номеров строк,
которая устанавливает соответствие
между объектным кодом и исходным модулем.
Директива {$L+} генерирует локальную
отладочную информацию, а именно, строит
список идентификаторов, локальных для
каждой процедуры или функции, для того,
чтобы отладчик мог хранить информацию
о них в процессе отладки. Когда Вы
используете директивы компилятора,
разделяйте их запятыми и без пробелов,
и ставя $ только перед первой директивой;
например {$D+,L+}.

Примечание:
Вы можете отключить эти переключатели
для сохранения памяти или дискового
пространства во время компиляции.

Когда
Вы выполняете пошаговую отладку, Turbo
Pascal будет иногда переключаться на экран
пользователя, выполнять Ваш код, а затем
возвращаться в интегрированную среду,
ожидая следующей команды. Вы можете
управлять переключением экрана с помощью
установок Options/Debugger/Display Swapping, которые
могут принимать 3 значения:

• Smart:
  Это режим по умолчанию. Среда IDE
  переключается на экран пользователя,
  когда программа обращается к видеопамяти
  или при вызове программы.

• Always:
  Переключение на экран пользователя
  происходит на каждом шаге.

• None:
  Переключение экранов не происходит.
  Интегрированная среда остается видимой
  все время. Если в программе предусматривается
  вывод на экран или требуется ввод
  информации, текст будет писаться на
  экране среды. Вы можете восстановить
  окна интегрированной среды, выбирая
  Ё/Refresh Display.

Начало
сеанса отладки.

Наиболее
быстрый способ начать отладку состоит
в загрузке программы и выборе команды
Run/Trace Into (F7). Программа будет компилироваться.
Когда компиляция завершится, редактор
отобразит на дисплей тело основной
программы с индикацией строки выполнения
на первом операторе begin. Пользователь
может начать трассировку программы с
этого места (нажать клавиши F7 или F8) или
использовать другие методы которые
приведены ниже.

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

• —
  Выбрать команду Run/Goto Cursor (или нажать
  клавишу F4), которая будет выполнять
  программу пользователя до достижения
  строки, помеченной курсором, а затем
  останавить работу программы.

• —
  Задать на указанной строке точку
  прерывания (выбрать команду Debug/Toggle
  Breakpoint или нажать на Ctrl-F8), затем выполнить
  программу (выполнить команду Run/Run или
  нажать Ctrl-F9); остановка будет происходить
  каждый раз при достижении заданной
  строки. Вы можете задать несколько
  точек прерывания, в этом случае программа
  будет делать остановку всякий раз при
  достижении какой-либо из этих точек.

Рестарт
сеанса отладки.

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

Turbo
Pascal также предлагает рестарт, если Вы
производите какие-либо изменения в
программе во время отладки. Например,
если Вы изменяете часть программы, а
затем выбираете любую команду выполнения
(нажимаете клавиши F7, F8, F4, Ctrl-F9 и т.д.), Вы
получите сообщение : Source modified, rebuild? (Y/N)
(исходный модуль модифицирован, нужно
повторить сборку? да/нет ). Если Вы
отвечаете Y, Turbo Pascal будет перекомпилировать
программу и возобновит отладку программы
с начала. Если Вы ответите N, Turbo Pascal
предполагает, что Вы уверены в своих
действиях, и продолжает сеанс отладки
дальше. (Любые изменения в программе,
которые Вы произвели, не будут влиять
на ее выполнение до тех пор, пока Вы не
перекомпилируете программу). Если Вы
добавили или удалили строки программы,
курсор выполнения не реагирует на эти
изменения, и может оказаться, что будет
выделяться ошибочная строка.

Окончание
сеанса отладки.

В
процессе отладки программы Turbo Pascal
хранит трассу того, что Вы делаете и где
находитесь в данный момент. Так как
пользователь может в процессе отладки
загружать и даже редактировать различные
файлы, Turbo Pascal не интерпретирует загрузку
другого файла в редактор, как конец
сеанса отладки. Поэтому, если вы желаете
выполнить или отладить другую программу,
нужно выполнить команду Run/Program Reset
(клавиша Ctrl -F2).

Трассировка
Вашей программы.

Простейшая
техника отладки — это пошаговая отладка,
которая трассирует внутри процедур и
функций. Загрузите программу RANGE.PAS в
Turbo Pascal.

{$D+,L+}

{Для
того, чтобы обеспечить

полную
генерацию отладочной информации}

{$R-}
{Для того, чтобы отключить проверку
диапазона}

program
RangeTest;

var

List:array
[1..10] of integer;

Indx:integer;

begin

for
Indx:=1 to 10 do List[Indx]:=Indx;

Indx:=0;

while
(Indx < 11) do

begin

Indx:=Indx+1;

if
List[Indx]>0 then

List[Indx]:=-List[Indx]

end;

for
Indx:=1 to 10 do writeln(List[Indx]);

end.

Начните
отладку, нажав клавишу F7. Это пошаговая
команда. Turbo Pascal произведет компиляцию
автоматически, а затем подготовится к
пошаговой обработке этой программы.
Заметим, что курсор выполнения расположен
на операторе begin (строка 7). Помните, что
курсор выполнения помечает следующую
строку программы, которая должна быть
выполнена.

Нажмите
клавишу F7 несколько раз. Курсор выполнения
переместится на оператор List[Indx]:=Indx и
остановится. Это значит, что строка
выполняется в цикле.

Выберите
команду Debug/Watches/Add Watch (Ctrl-F7) для просмотра
в окне Add Watch. Вы можете просматривать
значения переменных, структур данных
или выражений в окне Watch.

То,
что появится в окне Add Watch зависит от
того, где располагается курсор, когда
Вы нажимаете на клавишу Ctrl-F7. Если курсор
расположен на первой букве любой
алфавитно-цифровой строки, внутри строки
или сразу за ней, строка будет копироваться
в окно Add Watch и подсвечиваться. Так, если
курсор был спозиционирован на слове
Indx, то Indx появится в окне. Если в окне
необходимо что-либо изменить, начните
набор на клавиатуре и первоначальное
выражение и подсветка исчезнут.

Как
только появится окно Add Watch, независимо
от его содержимого, можно добавить в
него текст, если нажать клавишу Ў (которая
копирует дополнительный текст из
редактора). Поместите List в окно, используя
Ў, и нажмите Enter. Тогда в окне Watch в нижней
части экрана появится строка:

List
: (1,2,0,0,0,0,0,0,0,0)

Cнова
нажмите клавишу Ctrl-F7, наберите слово
Indx и нажмите Enter. Indx будет первым в списке
в окне Watch:

Indx
: 3

List
: (1,2,0,0,0,0,0,0,0,0)

Нажмите
клавишу F7 снова и Вы увидите, что значения
Indx и List в окне Watch изменятся, отражая
работу Вашей программы.

Как
только Вы войдете в цикл while, Вы снова
увидите, что значения Indx и List изменяются
шаг за шагом. Заметим, что эти изменения
в окне Window отражают действия каждой
строки цикла после нажатия клавиши F7.

Продолжайте
нажимать на клавишу F7, пока не достигнете
начала цикла while, c Indx равным 10. Во время
прохождения через цикл, Вы можете
наблюдать как изменяются значения в
окне Watch. Когда выполняется оператор

List
[ Indx ] := — List [ Indx ];

значение
Indx изменится на -11. Если Вы продолжаете
нажимать на F7, то обнаружится, что вы
вошли в бесконечный цикл.

Таким
образом, если Вы наберете такую программу,
она будет компилироваться и выполняться.
Получается бесконечный цикл, так как
цикл while выполняется 11 раз, а не 10, и
последнее значение переменной Indx равно
11. Так как массив List содержит только 10
элементов, значение List(11) будет указывать
на некоторую позицию памяти вне массива
List. Из-за способа распределения переменных
уже окажется, что значение List(11) займет
в памяти тоже место, что и переменная
Indx. Это значит, что при Indx=11, запись:

List
[Indx] := — List [Indx]

идентична
записи

Indx
:= -Indx.

Так
как значение переменной Indx равно 11, этот
оператор изменит ее значение на -11. В
результате в программе начнется повторное
выполнение цикла. Этот цикл теперь
изменяет дополнительные байты в месте,
соответствующем List[-11..0]. И т.к. значение
Indx никогда не будет заканчивать цикл
со значением большим или равным 11, то
цикл никогда не закончится.

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

Пошаговое
выполнение программы.

Различие
между командами Trace Into (F7) и Step Over (F8) в
том, что при использовании F7 осуществляется
трассировка внутри процедур и функций,
в то время как использование F8 приведет
к обходу вызовов подпрограмм. Эти команды
имеют особое значение при выполнении
оператора begin основной программы, если
программа использует модули, имеющие
раздел инициализации. В этом случае,
использование F7 приведет к трассировке
раздела инициализации каждого модуля,
что позволяет увидеть, что инициализируется
в каждом модуле. При использовании F8
эти разделы не будут трассироваться, и
курсор выполнения переходит на следующую
строку после begin.

Рассмотрим
следующий (неполный) пример программы:

($D+,L+)

program
TestSort;

const

NLMax=100;

type

NumList=array[1..NLMax]
of integer;

var

List
: NumList;

I,Const
: word;

procedure
Sort ( var L:NumList; Cnt:Integer);

begin

(sort
the list) (сортировка
списка)

end;
(of proc sort) (процедуры
Sort)

begin

randomize;

Count:=NLMax;

for
I:=1 to Count do

List[I]
:= Random(1000);

sort(List,Count);

for
I:=1 to Count do

Write(List[I]
:8);

Readln

end.
{программы
TestSort}

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

Да,
фактически, существует несколько
способов. Во-первых, Вы могли бы выделить
этот цикл в отдельную процедуру и нажать
клавишу F8 для того, чтобы обойти ее
трассировку, но это слишком нерационально.
Во-вторых, Вы могли бы установить внутри
программы точку прерывания. Мы объясним,
что это за точки прерывания, и как они
используются немного позже. В конце
концов, Вы могли бы использовать команду
Run/Go to Cursor (F4). Переместите курсор на
строку с вызовом Sort, а затем нажмите на
клавишу (F4). Ваша программа будет
выполняться до достижения строки,
помеченной курсором. Курсор выполнения
переместится на эту строку; затем Вы
можете начать трассировку с этого места,
нажимая на клавишу F7, для того, чтобы
можно было сделать трассировку внутри
Sort.

Команда
Run/Goto Cursor (F4) действует на вложенных
уровнях вызовов подпрограмм, даже если
их исходный код находится в другом
файле. Например, Вы могли бы разместить
курсор где-либо внутри процедуры Sort и
нажать на клавишу F4; программа выполнялась
бы до этой строки. По существу, Sort могла
бы быть выделена в отдельный модуль,
отладчик бы уже знал, когда нужно
остановиться и что отобразить.

Существуют
три случая, когда команда Go to Cursor (F4) не
будет выполнять программу до отмеченной
курсором строки.

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

Второй
случай, когда курсор расположен вне
процедурного блока, например, на операторе
объявления переменной или операторе
program. Отладчик будет выводить сообщение
«no code generated for this line» (для этой строки
код не генерируется).

Третий
случай, когда Вы располагаете курсор
на строке, которая никогда не выполняется.
Например, строка располагается выше
курсора выполнения (предполагается,
что вы находитесь не в цикле) или строка
является частью else — условного оператора,
когда выражение if имеет значение true. В
этом случае отладчик будет действовать
так, как если бы выполнялась команда
Run/Run (Ctrl-F9); программа будет выполняться
до конца или до точки прерывания.

Предположим,
что Вы трассируете процедуру Sort,затем
хотите завершить работу программы и
посмотреть выходные результаты. Каким
способом сделать это? Сначала нужно
переместить курсор к последнему оператору
end основной части программы, а затем
выполнить команду Run/Go to Cursor (F4). Или
проще, нужно выполнить команду Run/Run
(Ctrl-F9). Она позволяет отладчику продолжить
нормальное выполнение программы
пользователя. Программа будет выполняться
до конца, или до тех пор, пока Вы не
достигнете точки прерывания или не
будет нажат Ctrl-Break.

Использование
точек прерывания.

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

Примечание:
Вы можете иметь до 16 активных точек
прерывания.

Заметим,
что точки прерывания существуют только
во время сеанса отладки; они не сохраняются
в файле .EXE, если программа компилируется
на диск. Чтобы задать точку прерывания,
используйте обычные команды редактирования
для перемещения курсора на каждую строку
программы, где Вы хотите сделать паузу.
Каждый раз выполняйте команду Debug/Toggle
Breakpoint (Ctrl-F8). Когда строка отмечается
как точка прерывания, она высвечивается.
Это не должна быть пустая строка,
комментарии, директивы компиляции;
объявления констант, типов, меток,
переменных; заголовком программы,
модуля, процедуры или функции. Как только
Вы задали точки прерывания, выполняйте
программу с помощью команды Run/Run (клавиша
Ctrl-F9). Сначала программа будет выполняться
нормально. Когда встретится точка
прерывания, программа остановится.
Соответствующий исходный файл (основная
программа, модуль или включенный файл)
загружается в окно Edit, которое
визуализируется на экране и курсор
выполнения помещается на строку с точкой
прерывания.

Заметим,
что точка прерывания не высвечивается,
когда на ней находится курсор выполнения.
Если какие-либо переменные или выражения
были добавлены в окно Watch, то они также
выводятся на дисплей со своими текущими
значениями.

Затем,
пользователь может использовать любой
режим отладки.

• Вы
  можете осуществлять пошаговое выполнение
  программы, используя команду Run / Trace
  Into, Step Over или Go to Cursor (F7, F8 или F4). Вы можете
  проверить или изменить значения
  переменных.

• Вы
  можете добавить или удалить выражения
  из окна Watch.

• Можно
  назначить или удалить точки прерывания.

• Можно
  просмотреть выходные результаты
  программы, используя команду Windows/User
  Screen (Alt-F5).

• Вы
  можете перезапустить программу сначала
  ( Run/Program Reset и, затем, команду пошагового
  выполнения).

• Можно
  продолжить выполнение до следующей
  точки прерывания (или до конца программы),
  выполнив команду Run/Run (Ctrl-F9).

Для
удаления точки прерывания из строки
переместите курсор на данную строку и,
выполнив команду Debug/Toggle Breakpoint (или
нажмите Ctrl-F8) еще раз. Эта команда включает
или отключает точку прерывания в строке;
если она используется для строки с
точкой прерывания, то строка становится
нормальной.

Давайте
вернемся к примеру, который был рассмотрен
ранее.

begin
{основная часть программы Test.Sort}

Randomize;

Count
:= NLMax;

for
I := 1 to Count do

List
[I] := Random (1000);

Sort
( List,Count );

for
I := 1 to Count do

Write
( List [I] : 8 );

Readln

end.
{программа
Test.Sort}

Как
уже говорилось, идея была в том, чтобы
обойти первоначальный цикл и начать
трассировку с вызова процедуры Sort. Новый
вариант. Передвиньте курсор на строку
с вызовом процедуры и выполните команду
Debug/Toggle Breakpoint ( Ctrl-F8), которая отметит
строку, как точку прерывания. Теперь
выполните программу до этой точки,
используя команду Run/Run (Ctrl-F9 ). Когда
программа достигнет этой строки, она
остановится и позволит Вам начать
отладку.

Использование
Ctrl-Break.

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

Фактически,
отладчик автоматически подключает DOS,
BIOS и другие сервисные функции. Он знает,
является ли текущий выполняющийся код
программой DOS, программой BIOS или программой
пользователя. Когда Вы нажимаете на
клавишу Ctrl-Break, отладчик ждет, пока
программа выполняется сама. Затем он
делает пошаговое выполнение инструкций
машинного уровня, пока следующая
инструкция не будет в начале строки
исходного кода на Паскале. С этого
момента отладчик прекращает работу,
перемещает курсор выполнения на эту
строку и предлагает Вам нажать на клавишу
ESC.

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

Просмотр
значений.

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

procedure
Sort ( var L : NumList; C : word );

var

Top,Min,k
: word;

Temp
: integer;

begin

for
Top := 1 to C-1 do

begin

Min
:= Top;

for
k := Top+1 to C do

if
L[k] Top then

begin

Temp
:= L[Top];

Top
:= L[Min];

L[Min]
:= Temp;

end;

end;

end;
{процедуры
Sort}

Примечание:
Измените NLMax в теле программы на 10 так,
чтобы Вы могли работать с меньшим
массивом.

В
этой процедуре есть ошибки, будем
просматривать ее (используя команду
Run/Trace Into или клавишу F7) и наблюдать за
значениями переменных L, Top, Min и k.

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

Передвигайте
курсор к каждому идентификатору и
выполняйте команду Debug/Watch/Add Watch (Ctrl -F7)
для добавления каждого выражения в окно
Watch.

Результат
может выглядеть так:

k
: 21341

Min
: 51

Top
:21383

L
: (163,143,454,622,476,161,850,402,375,34)

Предполагается,
что Вы только что вошли в процедуру
Sort, курсор выполнения расположен на
начальном операторе begin. (Если Вы еще не
вошли в процедуру Sort, то для каждого
выражения в окне Watch будет появляться
сообщение «unknown identifier» (неизвестный
идентификатор), пока Вы не войдете в
процедуру). Заметим, что переменные K,
Min и Top имеют произвольные значения, т.к.
они еще не были инициализированы.
Значения переменной L, предположительно,
тоже должно быть произвольным; они не
будут таковыми при выполнении всей
программы; все они должны быть
неотрицательными и лежать в интервале
от 0 до 999.

Если
нажать на клавишу F7 четыре раза, то мы
продвинемся к строке if L[k]Top then, назад к
вершине внешнего цикла, и снова вниз к
строке if L[k] < L[Min] then. В этот момент окно
Watch будет выглядеть следующим образом
(для L даны предыдущие значения):

k
: 3

Min
: 2

Top
: 2

L
: ( 34,143,454,622,476,161,850,402,375,34 )

Теперь
Вы можете заметить две вещи. Первое,
последнее значение переменной L(34),
которое является также и наименьшим
значением, скопировалось в первое
значение L, и значение, которое уже было
там раньше (163), исчезло. Второе, переменные
Min и Top имели одинаковые значения во
время трассировки процедуры. Фактически,
Вы можете заметить, что переменная Min
получает значение переменной Top, но она
никогда не изменяется где-либо еще.
Однако, ниже цикла располагается
проверка:

if
Min<>Top then.

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

Min
:= k, вместо L[Min] := L[k].

Исправьте
строку, переместите курсор к первоначальному
оператору begin в процедуре Sort и выполните
команду Run/Go to Cursor (F4). Так как Вы изменили
программу, на экране появится окно с
вопросом Source modified, rebild? (Y/N) (исходный
модуль модифицирован, нужна ли сборка?
Да/Нет). Ответьте Y. Программа будет
перекомпилироваться, начнется ее
выполнение, затем произойдет остановка
на начальном операторе begin процедуры
Sort. Теперь программа работает верно.
Значение первого элемента теперь не
меняется на наименьшее из значений
элементов массива L, происходит
обмен-перемещение значения первого
элемента массива на место, где до этого
располагался элемент с наименьшим
значением. Затем процесс повторяется
со второй позицией, третьей и т.д., пока
список элементов не будет отсортирован
полностью.

Паскаль
— это один из самых простых языков, но
далеко не один из самых слабых. Изучать
мы с вами будем Turbo
Pascal 7.0 —
так вот на нем можно написать любую
программу, которая придет в голову. По
возможностям он не уступает ни СИ, ни
какому другому. На Паскале можно написать
программную оболочку (типа Norton Commander),
игрушку (типа Quake) или операционную
систему (типа MS-DOS). Программы на Turbo
Pascal пишутся только для платформы MS-DOS,
но никак не зависят от конфигурации
компьютера. Главным требованием к
компьютеру является только лишь то,
чтобы он был IBM PC-совместимый, что
естественно, если на нем установлен
MS-DOS.

Особой
теории по этому языку нет, чтобы хорошо
им овладеть (тем более если это ваш
первый язык программирования) необходимо
больше практики. Этим мы и начнем
заниматься уже в этом выпуске. При этом
вам понадобиться интерпритатор Turbo
Pascal 7.0 фирмы
Borland — я говорил где его можно достать в
предыдущем выпуске. Те, кто скачал его
с моего сайта (а скачало на данный момент
73 человека) или достал где-нибудь еще,
уже смогут попрактиковаться.

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

Итак,
поехали…

Сообщения и коды ошибок