Выводы по проделанной работе. 1 страница

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

1.12. Контрольные вопросы

1) Каков порядок создания программы в ИСР Turbo Pascal?

2) Какие основные функции выполняет ИСР Turbo Pascal?

3) Какие операции позволяет выполнять текстовый редактор Turbo Pascal при подготовке программы?

4) Как запустить программу, разработанную в ИСР Turbo Pascal?

5) Как сохранить программу под другим именем?

6) Как открыть новое окно редактирования?

7) Какими способами можно выйти из среды?

8) Как вызвать контекстную помощь?

9) Какова структура Pascal-программы?

10) Какие операторы используются для ввода и вывода значений переменных?

11) Какие действия выполняют операторы Write и Writeln?

12) Какие действия выполняют операторы Read и Readln?

13) Каким образом можно объявить переменную в языке Pascal?

Лабораторная работа №2. Разработка программы с разветвленной структурой

2.1. Цель работы

Приобретение навыков разработки программ разветвленной структуры на языке Pascal с использованием операторов условного перехода IF, выбора CASE и безусловного перехода GOTO. Получение навыков использования встроенного отладчика.

2.2. Задание на лабораторную работу

1. Освоить основные функции встроенного отладчика интегрированной среды Turbo Pascal (п. 2.5).

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

2.3. Требования к программе

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

– вывод номера варианта и сообщения о назначении программы;

– вывод фамилии и инициалов автора программы;

– вывод меню;

– ввод данных;

– вычисления и вывод результатов.

Результаты работы выводятся в отформатированном виде (с указанием количества знаков после десятичной точки).

2.4. Порядок выполнения работы

1. Получить вариант задания (п. 2.8).

2. Изучить основные функции отладчика Turbo Pascal (п. 2.5).

3. Подготовить текст программы и выполнить ее отладку с использованием интегрированной среды Turbo Pascal (п. 2.5, 2.6, 2.7).

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

5. Ответить на контрольные вопросы (п. 2.10).

6. Оформить отчёт (п. 1.11).

2.5. Отладка программы с использованием встроенного отладчика Turbo Pascal

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

– вместо Readln(N) написано Writeln(N);

– вместо R := A * B написано A := R * B;

– пропущен оператор или выражение;

– и т.д.

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

– построчная отладка (трассировка) текста программы с возможностью просмотра и изменения значения любой переменной (или выражения);

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

– наблюдение за переменными и выражениями, включенными в список «Watches»;

– доступ к регистрам микропроцессора;

– просмотр цепочки вызова подпрограмм (call stack).

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

1) Набрать простую программу, например:

1: 2: 3: 4: 5: 6: 7: 8: 9: 10:

program DebugTest; var A, B, R: Integer; begin Write('Введите A, B: '); Readln(A, B); R := A + B; R := R * A; Writeln('Результат: ', R); end.

В данной программе объявлены 3 целочисленные переменные A, B, R. Вначале программа печатает на экране подсказку «Введите А, В: », затем от пользователя требуется ввести 2 числа, которые будут записаны соответственно в переменные A и B. Далее программа складывает оба этих числа, и полученный результат присваивает в переменную R.

В следующей строке (№8) содержится оператор R := R * A, при этом сначала переменная R умножается на переменную A, после этого результат умножения присваивается опять в ту же самую переменную R. Таким образом, переменная R используется в данном примере несколько раз. В программировании повторное использование одних и тех же переменных встречается очень часто.

2) Для запуска программы под отладчиком следует щелкнуть клавишу F7 (меню Run \ Trace Into) или F8 (меню Run \ Step over). При отладке данного примера различия между F7 и F8 отсутствуют, однако если программа содержит процедуры или функции (см. лабораторную работу №5), созданные программистом, то F7 позволит попасть внутрь процедуры для ее отладки. В дальнейшем изложении будет упоминаться только клавиша F7. В результате нажатия клавиши F7 строка №4 (begin) окажется выделенной зеленым цветом, что свидетельствует об успешном запуске сеанса отладки.

3) Щелкнуть клавишу F7 еще раз – будет выделена строка №5 (Write…). Это означает, что при очередном нажатии F7 будет выполнен оператор, расположенный на выделенной строке.

4) Щелкнуть F7. В результате оператор Write будет выполнен, а дальнейшее управление перейдет к строке №6 (Readln).

5) Щелкнуть F7. Произойдет переключение в режим текстового ввода и программа будет ожидать от пользователя ввода двух чисел через пробел. После нажатия Enter в переменные A и B будут записаны числовые значения, которые ввел пользователь, а дальнейшее управление перейдет к строке №7 (R := A + B).

6) На данном этапе с помощью отладчика можно проверить, действительно ли переменные A и B содержат значения, введенные пользователем. Для этого следует установить курсор под переменной A, затем выбрать меню Debug \ Evaluate/modify (определить значение / изменить) или щелкнуть Ctrl+F4. Откроется окно «Evaluate and modify», в котором указано текущее значение переменной A (рисунок 2.1)

Рисунок 2.1 – Окно «Evaluate and modify»

В поле Expression можно указать имя переменной, но при необходимости можно ввести целое математическое выражение, например: (A * B) / (A + B). После нажатия кнопки «Evaluate» заданное выражение будет вычислено, а результат появится в строке «Result». При необходимости (в отладочных целях) в данном окне можно изменить значение указанной переменной. Для этого в строке «New value» следует ввести новое значение и нажать Modify.

7) Щелкнуть F7. В результате выражение в строке №7 будет вычислено, а результат записан в переменную R. Для просмотра вычисленного значения переменной R следует установить на нее курсор и нажать Ctrl+F4.

8) В некоторых случаях отладка упрощается, если программист всегда видит на экране значение заданного выражения (без необходимости постоянного нажатия Ctrl+F4). Для этого следует установить курсор на переменную R, щелкнуть меню Debug \ Add watch (Ctrl+F7) и нажать ОК. В результате в нижней части окна Turbo Pascal появится окно «Watches», в котором присутствует наименование переменной и ее значение, вычисленное автоматически (рисунок 2.2). При необходимости в список «Watches» можно добавить произвольное количество переменных или выражений.

Рисунок 2.2 – Окно «Watches»

9) Нажать F7 и убедиться в том, что значения заданных переменных в окне «Watch» обновляются автоматически.

10) Прервать отладку программы можно в любой момент с помощью меню Run \ Program Reset (Ctrl+F2).

11) Очень часто к трассировке программы требуется приступить не с момента ее запуска, а только при достижении определенной строки, подозреваемой в наличии ошибки. Для этого на заданную строку следует поместить точку останова. Разместите курсор на строке №8 (R := R * A), щелкните по ней правой кнопкой мыши и выберите пункт Toggle Breakpoint или нажмите Ctrl+F8. В результате строка будет выделена красным цветом, что свидетельствует о наличии точки останова (повторное нажатие Ctrl+F8 позволяет снять точку останова).

12) Запустить программу с помощью меню Run \ Run (Ctrl+F9), ввести два числовых значения через пробел и нажать Enter. В результате управление перейдет к строке, на которую установлена точка останова (теперь она будет окрашена зеленым цветом), а Turbo Pascal перейдет в режим отладки программы, в котором доступны все ранее описанные действия.

13) При необходимости к отлаживаемой программе можно добавить несколько точек останова (например, при отладке программы с разветвляющейся структурой, переход в ту или иную ветвь которой может произойти при выполнении или невыполнении некоторого условия). Для просмотра списка всех точек останова следует выбрать меню Debug \ Breakpoints. С помощью данного окна можно изменить (Edit) параметры точек останова (критерии срабатывания точки останова, например количество проходов через нее или выполнение заданного условия), быстро перейти к строке исходного кода (View), удалить выбранную точку останова (Delete), либо удалить все точки останова (Clear all).

14) Если в программе планируется использование всего одной точки останова, то в качестве более простой альтернативы можно использовать команду выполнения программы до выделенной строки. Для этого установите курсор на строке №9 (Write) и выберите меню Run \ Go to cursor (F4). В результате Turbo Pascal перейдет в режим отладки, в котором можно совершать все действия, упомянутые ранее.

2.6. Справочная информация по операторам ветвления языка Pascal

2.6.1. Оператор IF

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

if <условие> then <оператор>;

<остальные операторы программы>

Принцип действия данного оператора следующий: осуществляется проверка заданного условия. В том случае, если условие выполняется (дает результат «ИСТИНА», т.е. «TRUE»), то осуществляется переход к оператору, расположенному справа от THEN. После окончания работы этого оператора управление переходит к остальным операторам программы, которые расположены после символа «;». Если же условие не выполняется, то оператор, расположенный справа от THEN, пропускается и управление сразу переходит к остальным операторам.

Очень часто, в случае выполнения заданного условия, требуется выполнить не один, а сразу несколько операторов. В этом случае эти несколько операторов следует разместить внутри операторных скобок BEGIN..END.

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

Следует учитывать, что если некоторый набор операторов, состоящий из нескольких строк, находится внутри операторных скобок BEGIN..END, то всю конструкцию (с точки зрения оператора IF) следует рассматривать как «составной оператор»:

if A = B then

Begin

<оператор 1>;

<оператор 2>;

...

<оператор N>

end;

Условие – это любое выражение, результатом которого является логическое (Boolean) значение: True или False (Да или Нет). При составлении условия можно использовать операторы сравнения:

«=» – равно	«<>» – не равно	«>» – больше
«<» – меньше	«>=» – больше или равно	«<=» – меньше или равно

Операция (A = B) вернет True в том случае, если переменные A и B равны между собой; в противном случае вернет False;

Операция (A <> B) вернет True только в том случае, если переменные A и B не равны между собой.

Операция (A > B) вернет True в том случае, если переменная A имеет значение большее, чем значение переменной B.

Операция (A >= B) вернет True в том случае, если переменная A равна переменной B, либо имеет значение большее, чем у переменной B.

Кроме того, операции сравнения, возвращающие значения True или False можно комбинировать между собой с использованием логических операций:

«and» – логическое И	«or» – логическое ИЛИ
«not» – логическое НЕ	«xor» – исключающее ИЛИ

Выражение ((A < -1) or (A > 1)) вернет True, если значение переменной A меньше -1 или больше 1, т.е. оно не лежит в диапазоне [-1 ÷ 1].

Выражение ((A = B) and (A > C * C)) вернет True, если переменные A и B равны между собой и в то же время значение переменной A превышает значение переменной C, взятое в квадрате. Если не будет выполнено хотя бы одно из условий, то выражение вернет False.

Операция «not» инвертирует результат логического выражения, указанного справа, т.е. (not True) вернет False, а (not False) вернет True.

Выражение (not (A = B)) вернет True в том случае, если A не равно B.

Операция «xor» вернет True в том случае, одно из выражений дает True, а другое False. Например, выражение ((100 > 50) xor (29 = 30)) вернет True, поскольку одно из сравнений (100 > 50) дает True, а другое (29 = 30) – False.

Внимание! Программа на языке Pascal всегда должна иметь наименование, указанное после ключевого слова PROGRAM, секцию VAR с объявленными переменными и внешние операторные скобки BEGIN..END, в которых должны располагаться все необходимые операторы. Для краткости изложения материала эти ключевые слова в некоторых дальнейших примерах пропущены! Также пропущен код, осуществляющий присвоение значения некоторым переменным.

Ниже представлен один из таких примеров. В нем осуществляется ввод числа A; если введенное число отрицательное, то его значение заменяется на ноль.

Readln(A); {ввод числа A}

if A < 0 then A := 0; {заменяем на 0, если число отрицательное}

Writeln('A: ', A); {выводим на экран значение переменной A}

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

program Delenie;

Var

Delimoe, Delitel, Res: Real;

Begin

Delimoe := 100;

Readln(Delitel); {ввод значения делителя}

if Delitel = 0 then {проверка на равенство нулю}

begin {начало составного оператора}

Writeln('Ошибка: на ноль делить нельзя!');

Exit; {досрочный выход из программы}

end; {составной оператор закончился}

Res := Delimoe / Delitel; {осуществляем деление}

Writeln('Результат: ', Res); {вывод результата на экран}

end.

Очень часто возникает необходимость отреагировать не только на выполнение условия, но и на его невыполнение. Для этого к конструкции IF..THEN добавляется ключевое слово ELSE, определяющее начало альтернативной ветви выполнения программного кода. В этом случае конструкция IF..THEN выглядит следующим образом:

if <условие> then <оператор1> else <оператор2>;

if <условие> then begin <группа операторов 1>; end else begin <группа операторов 2>; end;

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

На рисунке 2.3 приведен пример схемы разветвляющегося алгоритма для двух форм оператора IF..THEN: с ключевым словом ELSE и без него.

Рисунок 2.3 – Схема алгоритма с оператором if…then
с else (слева) и без else (справа)

В представленном ниже примере осуществляется поиск наибольшего значения среди X и Y и сохранение найденного значения в переменную Max:

if X > Y then Max := X else Max := Y; Write('Максимум: ', Max);

if X >= Y then begin Max := X; Write('X больше или равен Y'); end else begin Max := Y; Write('Y больше X'); end; Write('Максимум: ', Max);

Кроме того, оператор IF..THEN может быть вложенным, причем уровень вложенности не ограничивается, например:

if X < -3 then

Y := X + 1

else if (X > 3) and (X < 10) then

Y := X * X

else if X >= 10 then

Begin

Y := Sqrt(X);

Writeln('Y: ', Y);

End

Else

Y := Y * Y;

Следует отметить, что подобные конструкции на практике могут быть весьма громоздкими. Для улучшения читабельности кода рекомендуется чаще пользоваться операторными скобками BEGIN..END с необходимым выравниванием. Важно помнить, что ключевое слово ELSE относится только к одному, ближайшему оператору IF..THEN, расположенному выше по коду.

2.6.2. Константы

Перед тем, как познакомиться с оператором CASE, необходимо дать определение понятию «константа». Константой в языке Pascal является некоторое значение (например, числовое), заданное непосредственно в тексте программы (т.е. пользователь вашей программы его не вводит). Например, в операторе «A := 100» переменной A присваивается явно заданное значение «100», т.е. константа. В языке Pascal различают два вида констант: именованные и неименованные. Для того чтобы константа была именованной, ее необходимо указать в секции CONST в разделе описаний программы: сначала указывается имя константы, затем символ «=», далее указывается необходимое значение, например:

program ConstExample;

Const

MinLimit = 1; {Минимальный лимит}

MaxLimit = 100; {Максимальный лимит}

Pi = 3.14; {Число Пи}

.......

Begin

A := MaxLimit; {Это более осмысленно, чем A := 100}

if B < MinLimit then...

.......

end;

После того, как константа объявлена, ее имя можно использовать в программе вместо числового значения, например «A := MaxLimit». В некоторых случаях это позволяет улучшить читабельность программы, а также упростить ее дальнейшую разработку. Значение именованной константы невозможно изменить при выполнении программы (в отличие от переменной).

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

Const

KiloWattCost = 3.45; {Стоимость 1 кВт/час }

2.6.3. Оператор выбора CASE

В том случае, если задана некоторая переменная порядкового типа (целочисленная, логическая или символьная) и на каждое возможное ее значение программа должна отреагировать индивидуально, рекомендуется использовать оператор выбора CASE. Логика работы оператора CASE аналогична логике IF..THEN, однако, использование оператора CASE в некоторых случаях позволяет значительно улучшить читабельность кода.

Оператор CASE имеет следующий формат:

case <переменная или выражение порядкового типа> of

<константа или список констант 1> : <оператор 1>;

<константа или список констант 2> : <оператор 2>;

·····························

<константа или список констант n> : <оператор N>;

Else

<альтернативная ветвь: оператор или группа операторов>

end;

Логика работы оператора CASE следующая: сначала программа определяет значение переменной или выражения порядкового типа (например, целочисленное). Далее отыскивается константа, совпадающая с указанным значением, после чего выполняется оператор, расположенный после символа «:». Если программе не удалось найти константу, совпадающую с заданным значением, то выполняется оператор из альтернативной ветви, расположенной после ключевого слова ELSE. Ключевое слово ELSE не является обязательным (его следует указывать, когда в этом возникает необходимость).

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

Write('Введите значение n: ');

Readln(n); {ожидаем, когда пользователь введет n}

case n of

0: {демонстрация использования операторных скобок begin...end}

Begin

Writeln('Сообщение: любое число в степени 0 равно единице!');

Y := 1;

end;

1: Y := X;

2: Y := X * X;

3: Y := X * X * X;

else {альтернативная ветвь кода}

{здесь дополнительный begin...end не требуется}

Writeln('Вы ввели недопустимое число!');

Y := 0;

end; {конец оператора case}

Writeln('Результат: ', Y); {вывод результата на экран}

Кроме одиночных констант могут быть заданы списки и/или диапазоны значений. Например:

case n of

0, 2..4 : Y := A * B; {оператор будет выполнен для n: 0, 2, 3, 4}

1, 5 : Y := A / B;

6 : Y := (A + B) * (A - B);

end;

Следует отметить, что при использовании оператора CASE действует ряд ограничений:

– значения констант не должны дублироваться; это ограничение действует также при использовании диапазонов;

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

– заданная переменная должна иметь порядковый тип (например, Integer, Byte, Char, Boolean); она не может быть объявлена как Real (дробный тип) или string (строка).

2.6.4. Оператор GOTO

Оператор безусловного перехода GOTO (англ.: перейти к) позволяет прервать выполнение текущего участка кода и перейти к другому участку, если он отмечен меткой безусловного перехода. Метка безусловного перехода объявляется в разделе LABEL и должна соответствовать требованиям, предъявляемым к идентификаторам (в порядке исключения допускается вместо наименования метки использовать целочисленные значения). После объявления метки в разделе LABEL ее можно указать в любом месте (но только один раз) в тексте программы. Для того чтобы перейти на заданную метку, следует вызвать оператор GOTO <имя_метки>, причем количество операторов перехода на одну и ту же метку в программе не ограничено:

····························· goto M1; {переходит вниз на метку M1} <операторы>; M1: <операторы>; ····························· goto M1; {переходит вверх на метку M1}

····························· label M1; var X, Y: Real; begin Readln(X); ····························· goto M1; ····························· M1: Y := X * 2 – 3 / X; Writeln('Y=', Y); ····························· end.

Следует отметить, что в современном программировании использование оператора GOTO не приветствуется, поскольку злоупотребление данным оператора приводит к сильному «запутыванию» кода. Для избежания использования оператора GOTO следует применять другие методы, например циклы и подпрограммы (см. следующие лабораторные работы).

2.7. Пример программы с разветвленной структурой

Составить программу вычисления функции:

program Lab2;

Label

M1, M2; {объявление меток}

Var

n: Integer;

X, Y: Real;

Flag: Boolean; {Признак выполнения пункта N1}

Begin

Writeln('Программа вычисления функции. Автор: Иванов И.И.');

{ Вывод на экран меню }

Writeln('Введите цифру для выполнения действия:');

Writeln('1 - Ввод данных');

Writeln('2 - Вычисление функции и вывод результатов');

Writeln('3 - Завершение работы программы');

Flag := False; { Первоначальная инициализация флага }

M1:

Write('Введите номер пункта меню: ');

Readln(n); { Ввод номера пункта меню}

case n of

1: { Ввод данных }

Begin

M2:

Write('Введите значение аргумента X: ');

Readln(X);

{ Проверка допустимости значения аргумента }

if X = 0 then

Begin

Writeln('X не может быть равным 0 по условию');

goto M2; { переход к M2 для повторного ввода данных }

End;

Flag := True; {Пункт №1 выполнен, установка флага в True}

end;

2: { Вычисление значения функции }

Begin

if not Flagthen{Если пункт №1 не выполнен}

Writeln ('Данные не введены, выполните пункт №1');

Else

begin {пункт №1 был выполнен}

{ Операторы вычисления и вывода значения функции }

if X > 0 then {если Х положительный}

Y := 1 / X

else{иначе Х < 0}

Y := X * X;

Writeln('При X = ', X:7:2, ' Y = ', Y:7:2);

End;

end;

3: Exit; { Выход из программы }

end; { end case }

goto M1; { переход в режим выбора пункта меню }

end. { Конец программы}

Данный пример требует пояснения. Программа начинается с объявления меток безусловного перехода (M1, M2) и объявления переменных, в том числе логической однобайтной переменной Flag: Boolean. Как ранее было сказано, логическая переменная может иметь всего два значения: True или False. В начале работы программы переменной Flag присваивается значение False. Это необходимо, поскольку если не выполнить этого присвоения, то в начале работы программы значение переменной Flag не определено, т.е. она случайным образом может быть равна False или True. Следует обратить внимание, что для пункта №2 оператора CASE осуществляется проверка переменной Flag (if not Flag then …), а поскольку осуществляется обращение к переменной в режиме чтения, то значение переменной обязательно должно быть присвоено заранее. В приведенном примере проверка (if not Flag then …) будет препятствовать выполнению операторов вычисления до тех пор, пока пользователь в пункте №1 не введет допустимое значение аргумента X (Flag в этом случае будет выставлен в True).