Если у вас возникли сложности с курсовой, контрольной, дипломной, рефератом, отчетом по практике, научно-исследовательской и любой другой работой - мы готовы помочь.
Предоплата всего
Подписываем
PAGE \* MERGEFORMAT 13
Міністерство освіти і науки, молоді та спорту України
Національний технічний Університет України
Факультет прикладної математики
«ПРОГРАМУВАННЯ»
(адреса на сервері кафедри: \\Torba\newsoft\Metodichki\ 1kurs_2012)
Київ
2012
ОГЛАВЛЕНИЕ
|
[0.0.1] “Київський політехнічний інститут” [1] МЕТОДИЧНІ ВКАЗІВКИ [2] ДО ВИКОНАННЯ ЛАБОРАТОРНИХ РОБІТ З ДИСЦИПЛІНИ [2.1] 1.1. Цель работы [2.2] 1.2. Задание на лабораторную работу [2.3] 1.3. Требования к программе [2.4] 1.4. Порядок выполнения работы [2.4.1] 1.5. Правила работы с методическими указаниями [2.5] 1.6. Разработка программы в интегрированной среде Turbo Pascal [2.5.1] 1.6.1. Почему Pascal? [2.5.2] 1.6.2. Порядок создания программы [2.5.2.1] Запуск интегрированной среды Turbo Pascal [2.5.2.2] Назначение пунктов меню Turbo Pascal [2.5.2.3] Подготовка нового текста программы [2.5.2.4] Описание клавиш редактирования текста [2.5.2.5] Сохранение текста программы в файл [2.5.2.6] Загрузка текста программы из файла [2.5.2.7] Запуск программы на выполнение [2.5.2.8] Просмотр результатов работы программы [2.5.2.9] Выход из среды Turbo Pascal [2.5.3] 1.6.3. Использование помощи в среде Turbo Pascal [2.6] 1.7. Сведения по структуре и операторам Pascal-программы [2.7] 1.8. Пример действий по подготовке и выполнению программы [2.7.0.1] Пример работы описанной выше программы [2.8] 1.9. Ошибки компиляции [2.9] 1.10. Варианты заданий [2.10] 1.11. Содержание отчета [2.11] 1.12. Контрольные вопросы
[3] [3.1] 2.1. Цель работы [3.2] 2.2. Задание на лабораторную работу [3.3] 2.3. Требования к программе [3.4] 2.4. Порядок выполнения работы [3.5] 2.5. Отладка программы с использованием встроенного отладчика Turbo Pascal [3.6] 2.6. Справочная информация по операторам ветвления языка Pascal [3.6.1] 2.6.1. Оператор IF [3.6.2] 2.6.2. Константы [3.6.3] 2.6.3. Оператор выбора CASE [3.6.4] 2.6.4. Оператор GOTO [3.7] 2.7. Пример программы с разветвленной структурой [3.8] 2.8. Варианты заданий [3.9] 2.9. Содержание отчета (см. пункт 1.11) [3.10] 2.10. Контрольные вопросы
[4] [4.1] 3.1. Цель работы [4.2] 3.2. Задание на лабораторную работу [4.3] 3.3. Требования к программе [4.4] 3.4. Порядок выполнения работы [4.5] 3.5. Оператор цикла FOR [4.5.0.1] Возведение в степень [4.6] 3.6. Тип данных «массив» – объявление и использование [4.7] 3.7. Использование меню для объединения подзадач а и б. [4.8] 3.8. Варианты заданий [4.9] 3.9. Содержание отчета (см. п. 1.11) [4.10] 3.10. Контрольные вопросы
[5] [5.1] 4.1. Цель работы [5.2] 4.2. Задание на лабораторную работу [5.3] 4.3. Требования к программе [5.4] 4.4. Порядок выполнения работы [5.5] 4.5. Оператор цикла REPEAT [5.6] 4.6. Оператор цикла WHILE [5.7] 4.7. Варианты заданий [5.8] 4.8. Содержание отчета (см. п. 1.11) [5.9] 4.9. Контрольные вопросы
[6] [6.1] 5.1. Цель работы [6.2] 5.2. Задание на лабораторную работу [6.3] 5.3. Требования к программе [6.4] 5.4. Порядок выполнения работы [6.5] 5.5. Программирование процедур и функций на языке Pascal [6.5.1] 5.5.1 Объявление функции [6.5.2] 5.5.2 Объявление процедуры [6.5.3] 5.5.3 Передача аргументов в подпрограмму с использованием параметров-значений и параметров-переменных [6.5.4] 5.5.4 Локальные и глобальные переменные и их область действия [6.5.5] 5.5.5 Предварительное описание подпрограммы [6.5.6] 5.5.6 Рекурсивный вызов подпрограммы [6.6] 5.6. Варианты заданий [6.7] 5.7. Содержание отчета (см. п. 1.10) [6.8] 5.8. Контрольные вопросы
[7] [7.1] 6.1. Цель работы [7.2] 6.2. Задание на лабораторную работу [7.3] 6.3. Требования к программе [7.4] 6.4. Порядок выполнения работы [7.5] 6.5. Операторы объявления и обработки символов и строк на языке Pascal [7.5.1] 6.5.1. Операторы определения и обработки данных символьного типа [7.5.2] 6.5.2. Определение переменных строкового типа STRING. Операторы обработки строк [7.6] 6.6. Пример программы [7.7] 6.7. Варианты заданий [7.8] 6.8. Содержание отчета (см. п. 1.10) [7.9] 6.9. Контрольные вопросы [8] Лабораторная работа № 7. Работа с файлами на языке Pascal [8.1] 7.1. Цель работы [8.2] 7.2. Задание на лабораторную работу [8.3] 7.3. Требования к программе [8.4] 7.4. Порядок выполнения работы [8.5] 7.5 Основы работы с записями и файлами на языке Pascal [8.5.1] 7.5.1. Определение типа данных RECORD [8.6] 7.5.2. Операторы для работы с файлами в Pascal [8.7] 7.6 Пример программы [8.8] 7.7. Варианты заданий [8.9] 7.8. Содержание отчета (см. п. 1.11) [8.10] 7.9. Контрольные вопросы
[9]
[10] |
Лабораторная работа №1. Разработка программы с линейным алгоритмом выполнения.
Приобретение навыков по работе с интегрированной средой разработки Turbo Pascal. Изучение принципов разработки программ линейной структуры. Получение навыков объявления типов переменных в зависимости от характера входных и выходных данных.
1) Изучить основные возможности интегрированной среды разработки (ИСР) Turbo Pascal для подготовки текста программы и запуска ее на выполнение.
2) Изучить структуру программы на языке Pascal, способы объявления переменных, операторы ввода и вывода данных.
3) Разработать линейную программу в соответствии с вариантом задания.
Программа должна выводить:
– номер варианта и сообщение о назначении программы;
– фамилию и инициалы автора программы;
– информационные сообщения о необходимости ввода данных;
– сообщение с результатами, полученными в ходе работы программы; при этом текст сообщения должен включать наименование результата и вычисленное значение результата, например «Полученная сумма: 123.45»; при использовании переменных, объявленных как дробные, значение результата должно быть представлено в отформатированном виде (с указанием количества знаков после десятичной точки).
1. Важно! Изучить правила работы с методическими указаниями (п. 1.5).
2. Получить вариант задания (п. 1.10).
3. Изучить функции системы Turbo Pascal для подготовки текста (исходного кода) программы и запуска ее на выполнение. Освоить функции редактора для подготовки текста программы (п. 1.6).
4. Изучить структуру Pascal-программы, способы определения переменных стандартных типов и операторы ввода и вывода (п. 1.7).
5. Разработать программу в соответствии с вариантом задания и выполнить ее запуск с помощью среды Turbo Pascal (п. 1.8).
6. Показать разработанную программу преподавателю.
7. Устно ответить на контрольные вопросы преподавателя (п. 1.12).
8. Оформить отчет в соответствии с рекомендациями, данными в п. 1.11.
Важно! Обучаемый должен внимательно и вдумчиво читать описание каждой лабораторной работы!
Методические указания построены по принципу «от простого к сложному». В первой лабораторной работе обучаемый знакомится с очень важными элементами языка Pascal – операторами ввода и вывода. Ничего сложного в первой лабораторной работе нет, поэтому любой студент с ней справится без труда, если уделит ей некоторое время.
В результате обучаемый должен четко понимать принцип работы этих операторов. Если студент, в силу каких-либо обстоятельств, не сможет справиться с данной лабораторной работой, то нет смысла приступать к следующим, т.к. все они основаны на операторах ввода и вывода.
Нельзя приступать к следующей лабораторной работе, если не сделана предыдущая, т.к. все они взаимосвязаны. Каждая очередная лабораторная работа основана на предыдущей.
Перед тем, как приступить к выполнению лабораторной работы, необходимо ознакомится с ее описанием. Для каждой лабораторной работы дано достаточное для ее выполнения описание. Предполагается, что обучаемый может самостоятельно с ним ознакомиться.
Методические указания содержат всю необходимую теоретическую часть, поэтому дополнительная литература по языку Pascal не требуется. Однако при необходимости студент может усилить свои знания с помощью дополнительной литературы, которую он без труда сможет найти в сети Интернет.
Если после прочтения методических указаний у обучаемого остаются вопросы, следует обратиться к преподавателю.
У обучаемого может возникнуть справедливый вопрос: «почему мне преподают Pascal, если в мире все программируют на 1C, Delphi, Java, C#, C++ VisualBasic, PHP и т.д.». Но давайте вспомним, как мы учились разговаривать, ходить, читать, писать! У многих первое слово было «мама», перед уверенной походкой ребенок ползал на четвереньках, нас учили читать и писать сначала по буквам, затем по словам, после чего мы научились формулировать свою мысль в виде предложения.
Нельзя сесть за штурвал пассажирского лайнера, не проведя годы тренировок на простых самолетах, но даже их доверяют далеко не сразу, а лишь спустя годы учебы.
Так и в программировании: не будет никакого смысла пытаться освоить сложные языки Delphi, Java, C#, если вы не изучили основы программирования.
Для изучения основ программирования необходимо использовать простой язык. Таким языком является Pascal. Первоначально он разрабатывался с одной целью – стать учебным языком программирования, однако решение вышло настолько удачным, что Pascal стал лучшим языком профессионального программирования и удерживал эту планку длительное время.
Язык Pascal очень легко преподавать и очень легко учить. При этом совершенно исключена такая ситуация: студент спрашивает преподавателя «что означает этот оператор», а преподаватель ему отвечает: «не спрашивай, просто так надо, тебе это сейчас бесполезно объяснять, все равно не поймешь, этот материал вы будете проходить через полгода». Такая ситуация является совершенно обычной, если для основ программирования преподаватель выбирает другой язык, например Си++. Язык Pascal проектировался таким образом, чтобы исключить саму возможность появления таких «неудобных» вопросов и столь «нелепых» ответов.
Несмотря на свою простоту, язык Pascal позволяет разрабатывать программы какой угодно сложности. Такие важные понятия, как «строгая типизация», «предварительное объявление» и др. позволяют сформировать у обучаемого очень хороший фундамент, благодаря которому в дальнейшем любой другой язык программирования можно освоить за месяцы, или даже за недели (особенно, если в языке отсутствует строгая типизация, например 1С).
Кроме того, Pascal является современным и полноценным языком, которым до сих пор пользуются многие программисты, например в средах Free Pascal, Lazarus, Delphi и др. Инструменты Free Pascal и Lazarus являются «кроссплатформенными», поэтому разработанная в них программа сможет функционировать практически в любой операционной системе (Windows, Linux, Unix, MacOS и т.д.) и на любой аппаратной платформе (персональные и карманные компьютеры, смартфоны, iPhone, iPod и т.д.).
В дальнейшем, если потребуется программирование «железа», то у обучаемого не должно возникнуть больших сложностей в изучении «родного» для железа языка – Си, Си++. Примечательно то, что для изучения языка Си чаще всего быстрее выучить сначала Pascal, а уже затем Си, чем сразу начинать с изучения языка Си.
При выполнении лабораторных работ используется ИСР Turbo Pascal (допускается ИСР Free Pascal), обеспечивающая следующие возможности:
– подготовка текста программы;
– компиляция (перевод исходного кода программы в машинный код);
– запуск на выполнение;
Ниже представлены необходимые сведения о возможностях ИСР.
Запуск интегрированной среды Turbo Pascal
Запустить программу «Проводник» (щелкнуть «Пуск \ Мой компьютер»), выбрать диск, на котором расположены исполняемые файлы, найти каталог «TP», затем «BIN», затем найти файл TURBO.EXE (либо просто TURBO с пометкой «Приложение») и запустить его путем двойного щелчка левой кнопки мыши или нажатием клавиши ввод.
В результате на экране появится окно Turbo Pascal, как показано на рисунке 1.1.
Рисунок 1.1 – Окно Turbo Pascal
Окно Turbo Pascal состоит из следующих элементов:
– пункты меню, расположенные в верхней части окна (File, Edit и т.д.);
– окно редактора когда, в котором следует вводить текст программы;
– строка подсказок в нижней части окна.
Назначение пунктов меню Turbo Pascal
– File – выполнение операций с файлами (открыть, сохранить и др.);
– Edit – команды редактирования текста (копировать текст, вставить текст, удалить текст и т.д.);
– Search – команды поиска;
– Run – запуск программы;
– Compile – компиляция программы;
– Debug – отладка программы;
– Tools – использование дополнительных программных инструментов;
– Options – содержит пункты, позволяющие выполнить гибкую настройку среды Turbo Pascal, включая компилятор, отладчик и редактор кода;
– Window – команды управления всеми открытыми окнами;
– Help – команды, обеспечивающие помощь программисту.
Для выполнения требуемой функции (т.е. для выбора меню) можно воспользоваться любым из способов, указанных ниже:
а) нажать клавишу F10, затем, перемещая клавишами , курсор (выделенный прямоугольник), выбрать нужный пункт меню и нажать клавишу Enter;
б) одновременно нажать Alt и клавишу с выделенной буквой в нужном пункте меню; например, для раскрытия списка команд меню, содержащихся в пункте «File», следует нажать Alt+F;
в) щелкнуть мышкой на нужном пункте меню.
В дальнейшем, если, например, указано «выберите меню File \ Save», это означает, что необходимо любым из способов выбрать меню «File», а затем в раскрывшемся списке подчиненного меню выбрать пункт «Save».
Подготовка нового текста программы
Выбрать меню File \ New, после чего откроется новое окно редактора кода, которое можно использовать для набора текста программы.
Вся работа с текстом программы происходит в окне редактирования. При этом используются приемы, принятые во многих других текстовых редакторах (Блокнот, MS-Word, OpenOffice и др.). Самую подробную информацию о возможностях редактора кода Turbo Pascal можно узнать на английском языке в разделе помощи. Для этого нажмите F1 и в появившемся окне помощи выберите пункт Using the editor.
Описание клавиш редактирования текста
– Ins – переключение между режимами «вставка» и «замена». Рекомендуется работать в режиме «вставка» (при этом курсор представляется в виде мигающего символа подчеркивания «_»). Если по ошибке включен режим «замена» (случайно нажали клавишу Ins), то текст, расположенный справа от курсора, будет затираться.
– Enter – вставка новой строки; если перед нажатием Enter курсор находился в середине предложения, то оно в результате будет разделено и расположится на двух строках;
– клавиши со стрелками – сдвиг курсора в соответствующем направлении;
– End – перемещение курсора в конец строки;
– Home – перемещение курсора в начало строки;
– PgUp – сдвиг текста программы на страницу назад;
– PgDn – сдвиг текста программы на страницу вперед;
– Ctrl+стрелка вправо – перемещение курсора на слово вправо;
– Ctrl+стрелка влево – перемещение курсора на слово влево;
– (BackSpace) – удаление символа слева от курсора;
– Del – удаление символа над курсором;
– Ctrl+Del – удаление выделенного участка текста;
– Alt+BackSpace – отменяет последнее изменение;
– Ctrl+Ins – копирование выделенного участка текста в буфер обмена;
– Shift+Ins – вставка текста из буфера обмена в позицию курсора.
Рекомендуется запомнить клавиши редактирования текста, поскольку благодаря этим клавишам работа с редактором кода значительно упрощается.
Сохранение текста программы в файл
Необходимо своевременно и регулярно сохранять исходный код программы. Для сохранения текста программы в файл следует:
– выбрать меню «File \ Change dir…» (Файл \ Сменить директорию) и указать диск и каталог, в который следует сохранить текст программы;
– выбрать меню «File \ Save as…» (Файл \ Сохранить как) и ввести имя файла в поле Save file as (по умолчанию Turbo Pascal устанавливает имя NONAMExx.PAS; необходимо указать другое наименование файла, используя при этом англоязычные символы);
В дальнейшем для сохранения изменений будет достаточно щелкнуть клавишу F2 (или выбрать меню File \ Save).
Загрузка текста программы из файла
– выбрать меню «File \ Change dir…» (Файл \ Сменить директорию) и указать диск и каталог, в котором находится pas-файл с сохраненным текстом программы;
– выбрать меню «File \ Open»; откроется окно с возможностью выбора имени файла программы (это окно можно вызвать также путем нажатия клавиши F4); нажмите Tab для перехода к списку файлов, выберите необходимый файл и нажмите Enter. Исходный код программы, содержащийся в указанном файле, будет загружен в окно редактора кода.
Запуск программы на выполнение
Для запуска программы на выполнение воспользуйтесь комбинацией клавиш Ctrl+F9. Будет произведена компиляция программы (преобразование исходного текста программы в машинный код), в ходе выполнения которой на экране будет отображаться окно компиляции «Compiling». Если в ходе компиляции обнаружены ошибки, то выдается сообщение об ошибке и курсор указывает место, где необходимо внести исправления (см. п. 1.9). Если ошибок не обнаружено, то программа будет запущена на выполнение. При этом программа выводит пользователю подсказки для ввода данных, осуществляет необходимые вычисления и печатает на экране результаты своей работы.
Просмотр результатов работы программы
После того, как программа полностью выполнилась, на экране вновь появится окно редактора кода. Если вы не успели увидеть результаты работы программы, то нажмите клавиши Alt+F5: в результате будет снова открыто окно с результатами работы программы.
Выход из среды Turbo Pascal
Выход из Turbo Pascal выполняется с помощью нажатия клавиш Alt+X или выбора пункта меню File \ Exit. Если программа не была сохранена или были внесены изменения после ее сохранения, то вам будет предложено сохранить текст программы.
Для помощи программисту в интегрированной среде Turbo Pascal предусмотрена обширная система справки (пункт Help главного меню).
Для открытия окна Help можно:
– нажать F1 (в любой момент времени);
– установить курсор под словом и нажать клавиши Ctrl+F1 для получения справочной информации по выбранному слову.
Для закрытия окна Help нажмите Esс.
Структура программы на языке Pascal имеет следующий вид:
program ProgramName; {Имя программы}
{Раздел описаний}
begin {BEGIN – это начало программы}
{Раздел операторов}
end. {END. (с точкой) – это конец программы}
Вначале должно быть указано имя программы (после ключевого слова PROGRAM), затем следует раздел описаний. После раздела описаний следует раздел операторов, расположенный внутри ключевых слов BEGIN и END. В конце программы, после ключевого слова END должна стоять точка.
Ниже представлен пример самой простой программы на языке Pascal, которая выводит на экране надпись «Hello World!» (Привет, мир!):
program Hello;
begin
Writeln('Hello, World!'); {Печать текста «Hello, World!» на экране}
end.
Рекомендуется напечатать текст простой программы в среде Turbo Pascal и запустить ее на выполнение (см. п. 1.6.2). Для просмотра текста, напечатанного на экране, необходимо нажать Alt+F5.
Внимание! Если установленная у вас версия Turbo Pascal не поддерживает русский язык, то для вывода сообщений и печати комментариев используйте транслитерацию с помощью английских символов. Например, вместо сообщения «Введите любое число» вы можете написать «Vvedite luboe chislo». Если вы в достаточной мере владеете английским языком, то можно написать «Enter any number». В методических указаниях для вывода сообщений и комментариев используется преимущественно русский язык, но это совершенно не принципиально.
Ниже приведен пример программы, требующей от пользователя ввести некоторое число, далее это число возводится в квадрат и полученное значение печатается на экране:
program Kvadrat; {Название программы: Квадрат}
var {VAR - область объявления переменных}
X, Xkvadr: Real; {Объявление переменных X и Xkvadr}
begin {Начало программы}
Writeln('Введите любое число:'); {Печатает подсказку для пользователя}
Readln(X); {Ожидает, когда пользователь введет число и нажмет ENTER}
{Число будет записано в переменную X}
{Возведение X в квадрат и присвоение результата в переменную Xkvadr}
Xkvadr := X * X;
{Печатает результат возведения в квадрат на экран: }
Writeln('Результат возведения в квадрат:', Xkvadr)
{Для просмотра результатов нажмите клавиши Alt+F5}
end. {Конец программы}
Ниже представлены необходимые пояснения к данному примеру:
1) Выделенные жирным шрифтом слова PROGRAM, VAR, BEGIN, END являются «ключевыми словами». Ключевые слова определяют структуру программы, они располагаются в строго определенных местах. Turbo Pascal выделяет ключевые слова определенным цветом (см. рисунок 1.1). Вы не можете объявить свою переменную с таким же именем.
2) Имя программы (Kvardat), имена переменных (X, Xkvadr), а также наименования любых объектов на языке Pascal являются «идентификаторами» и могут состоять только из латинских символов, цифр от 0 до 9 и знака подчеркивания «_». Длина идентификатора не должна быть более 32 символов, наименование идентификатора не может начинаться с цифры. Примеры правильных идентификаторов:
Laba1, My_First_Program, Kolvo1, RadiusKruga.
Неправильные идентификаторы: 1Laba (цифра спереди), Lab rab 1 (пробел недопустим), ПерваяПрограмма (русские символы недопустимы).
3) Каждая строка в примере снабжена подробным комментарием. Комментарии в программе являются поясняющим текстом, основная цель которого – не дать программисту забыть назначение тех или иных участков его программы даже по прошествии длительного времени. Для оформления комментариев служат фигурные скобки, например { Это комментарий } или круглые скобки со звездочками, например (* Это тоже комментарий *).
4) Каждый оператор (т.е. инструкция, выполняющая какое-либо действие) должен заканчиваться символом «;». Однако, если оператор расположен непосредственно перед END, то символ «;» не является обязательным. Символ «;» в языке Pascal отделяет операторы друг от друга.
5) При выводе сообщения на экран (с помощью оператора Writeln) текст должен располагаться внутри одинарных кавычек (апострофов). На клавиатуре символ апострофа «'» расположен на той же клавише, где буква «Э», рядом с «ENTER». Пример: Writeln('Введите любое число:').
6) При использовании оператора Writeln, осуществляющего печать заданного текста на экране, все параметры должны находиться в круглых скобках. Если необходимо вывести на экран несколько значений (текстовых и числовых), то между ними должна стоять запятая «,».
7) При использовании оператора Readln, требующего от пользователя ввести необходимые данные, переменная, в которую будет записано введенное пользователем число, должна находиться в круглых скобках. Кроме того, с помощью одного оператора Readln можно потребовать от пользователя ввести сразу несколько чисел. В этом случае в программе должно быть объявлено соответствующее количество переменных, а в операторе Readln эти переменные должны быть перечислены через запятую «,».
8) Перед тем, как с помощью оператора Readln требовать от пользователя ввести какие-либо данные, необходимо с помощью оператора Writeln информировать пользователя о том, какие данные ему нужно ввести.
9) Оператор присваивания «:=» работает следующим образом: сначала вычисляется выражение, расположенное справа от оператора присваивания, затем полученный результат записывается в переменную, расположенную слева от оператора присваивания. Эта переменная должна быть использована в дальнейших операторах программы, например в операторе Writeln для вывода ее значения на экран.
10) Числовое выражение, расположенное справа от оператора присваивания, может включать математические операции сложения «+», вычитания «–», умножения «*», деления «/», целочисленного деления «div» (отбрасывается остаток), получения остатка от целочисленного деления «mod». Операции умножения и деления являются более приоритетными, чем операции сложения и вычитания. Как и в математике, приоритетом вычисления можно управлять с помощью круглых скобок, например: Y := ((A + B) / (A – B)) * X.
В языке Turbo Pascal отсутствует операция возведения в степень, однако эту «проблему» можно легко обойти. Например оператор Y := X * X * X возводит число X в 3-ю степень и записывает результат в переменную Y.
11) Перед использованием любой переменной ее необходимо объявить в разделе описаний. Если переменная не объявлена, то ее нельзя указывать в операторах Writeln, Readln, а также в любых других операторах (будет выдаваться ошибка «Unknown identifier», см. п. 1.9).
12) Переменные в языке Pascal объявляются в секции VAR. Сначала указывается имя переменной, затем символ двоеточия «:», после чего следует тип переменной и завершается строка символом «;». В одной секции VAR можно объявить любое количество переменных. Если нужно объявить несколько переменных с одинаковым типом, то можно перечислить эти переменные через запятую. Пример:
var
N: Integer;
S, M1, M2: Real;
Тип INTEGER соответствует целым числам. Переменная N, объявленная целочисленной, может принимать любое целое значение от -32768 до 32767. Эти ограничения связаны с тем, что для любой переменной в языке Pascal выделяется некоторый ограниченный объем памяти. Для переменной, имеющей тип INTEGER, выделается 2 байта (16 бит) памяти. Кроме того, в языке Pascal вы можете для объявления целочисленной переменной использовать следующие типы:
|
Наименование типа |
Диапазон значений |
Размер памяти |
|
Shortint |
-128 … 127 |
1 байт |
|
Longint |
-2147483648 ...2147483647 |
4 байта |
|
Byte |
0 ... 255 |
1 байт |
|
Word |
0 ... 65535 |
2 байта |
Тип REAL соответствует дробным (вещественным) числам. Это означает, что переменная S может иметь любое числовое значение, как целое, так и дробное, например: 0, 1, 1.5, -100, -123.12313 и т.д. В качестве разделителя целой и дробной части используется точка, а не запятая, как это принято в математике. Для переменной, объявленной как REAL, выделяется 6 байтов памяти, диапазон значений: от -1.7E38 до +1.7E38. Особенность вещественных чисел заключается в том, что они хранят дробные числа с ограниченной точностью. Например, число 3.3333333… (в периоде) в принципе невозможно хранить с бесконечной точностью (понадобилось бы бесконечное количество байтов).
Внимание! Вы должны хорошо понимать, какие действия выполняет каждый из операторов в данном примере. Если есть непонятные моменты, обратитесь к преподавателю за разъяснениями.
При выполнении данной лабораторной работы для вывода на экран сообщений (подсказок пользователю) можно использовать операторы типа:
Write('Сообщение о вводе данных');
Writeln('Сообщение о выводе результатов');
Оператор Write выводит на экран заданный текст и оставляет мигающий курсор на той же строке (в конце).
Оператор Writeln также печатает на экране заданный текст, но при этом переводит курсор на следующую строку.
Для ввода данных с клавиатуры можно использовать операторы типа:
Read(S1);
Readln(A, B, C);
В первом случае при выполнении оператора Read(S1) программа будет ждать, пока пользователь не введет с клавиатуры какое-либо число и нажмет Enter. После этого мигающий курсор останется на той же самой строке, а введенное пользователем число будет записано в переменную S1.
Во втором случае программа будет ожидать от пользователя, когда он введет друг за другом три числа, разделяя их пробелом, и нажмет Enter. Курсор перейдет на следующую строку, а введенные значения будут сохранены соответственно в переменные A, B и C.
Ниже представлен пример ввода данных: программа печатает приглашение для ввода данных, а пользователь на той же самой строке должен ввести число и нажать Enter. После этого курсор перейдет на следующую строку, а в переменную R будет записан радиус круга:
Write('Введите радиус круга: ');
Readln(R);
Для вывода результатов вычислений на экран можно использовать операторы типа:
Write(Res:8:2); {Только если Res – дробная переменная}
Writeln(Res:8:2);
где «8» – общее количество символов, отведенных для представления числового значения на экране (включая знак числа, целую часть, десятичную точку и дробную часть), «2» – количество знаков после десятичной точки.
В том случае, если переменная-результат объявлена как целочисленная, подобное форматирование не требуется.
Пример вывода целочисленного (Integer) результата:
Writeln('Периметр прямоугольника: ', Per);
Пример вывода вещественного (Real) результата:
Writeln('Объем конуса V: ', V:8:2);
Запустите Turbo Pascal и введите текст своей программы, например:
{Программа вычисления суммы двух чисел}
program FirstProgram;
var
A, B: Real; {вводимые данные}
Sum: Real; {сумма чисел }
begin
Writeln('Программа вычисления суммы двух чисел');
Writeln('Автор: Иванов И.И.');
Write('Введите два любых числа через пробел: ');
Readln(A, B);
Sum := A + B; {вычисление суммы двух чисел... }
Writeln('Сумма: ', Sum:8:2);
end.
Для сохранения программы выберите меню File \ Save (или F2).
Для выполнения программы следует выбрать Run \ Run в главном меню (или нажать Ctrl+F9). При наличии ошибки см. п. 1.9.
Пример работы описанной выше программы
1) На экран выводятся сообщения, которые заданы в операторах Writeln вашей программы:
> Программа вычисления суммы двух чисел
> Автор: Иванов И.И.
> Введите два любых числа через пробел:
2) Пользователь вводит через пробел два числа и нажимает Enter.
3) На экран выводится следующее сообщение:
> Сумма:
а за ним – вычисленная сумма двух введенных чисел.
Для просмотра результатов работы программы, выберите меню Debug \ User Screen (Отладка \ Окно пользователя) или нажмите Alt+F5.
Если в процессе компиляции текста программы Turbo Pascal обнаружит ошибку, то курсор будет автоматически перемещен на строку с ошибкой, а в красной рамке появится сообщение об ошибке в формате:
Error <код_ошибки>: Сообщение об ошибке на английском языке
Наиболее вероятные ошибки компиляции:
Error 2: Identifier expected {Ожидается идентификатор}
Error 3: Unknown identifier {Неизвестный идентификатор}
Error 4: Duplicate identifier {Идентификатор дублируется}
Error 12: Type identifier expected {Ожидается тип идентификатора}
Error 26: Type mismatch {Несоответствие типов}
Error 36: BEGIN expected {Ожидается BEGIN}
Error 37: END expected {Ожидается END }
Error 62: Division by zero {Деление на 0}
Error 85: ";" expected {Ожидается ";"}
Error 86: ":" expected {Ожидается ":"}
Error 87: "," expected {Ожидается ","}
Error 88: "(" expected {Ожидается "("}
Error 89: ")" expected {Ожидается ")"}
Error 91: ":=" expected {Ожидается ":="}
Error 94: "." expected {Ожидается "."}
Error 113: Error in statement {Ошибка в операторе}
Перечень задач:
1) Вычислить площадь треугольника.
2) Вычислить площадь круга.
3) Вычислить площадь трапеции.
4) Вычислить площадь квадрата.
5) Вычислить объем куба.
6) Вычислить среднее арифметическое трех чисел.
7) Вычислить квадрат числа.
8) Вычислить периметр треугольника.
9) Вычислить периметр прямоугольника.
10) Вычислить квадрат разности двух чисел.
11) Вычислить квадрат суммы двух чисел.
12) Вычислить объем шара.
13) Вычислить длину средней линии трапеции.
14) Вычислить процент от заданного числа.
15) Вычислить куб разности двух чисел.
16) Вычислить объем цилиндра.
17) Вычислить объем конуса.
18) Вычислить объем треугольной пирамиды.
19) Вычислить разность квадратов двух чисел.
20) Вычислить длину радиуса окружности заданной площади.
1) Цель работы.
Допускается использовать формулировку, приведенную в соответствующем пункте методических указаний на выполнение лабораторной работы.
2) Задание на лабораторную работу.
Привести задание на лабораторную работу, требования к программе, указать номер варианта и задание из варианта.
3) Состав и структура данных.
Привести состав и тип входных и выходных данных. Если имеются ограничения по диапазону возможных значений (например, ноль в знаменателе, корень из -1 и т.п.), то указать их.
4) Описание программы.
Привести словесное описание программы, из которого должно быть понятно, какие операции выполняет программа и какие действия производит пользователь для ввода данных и получения результата.
5) Схема алгоритма программы.
Схема алгоритма программы должна быть составлена с учетом особенностей каждой лабораторной работы. Пример схемы алгоритма для лабораторной работы №1 приведен на рисунке 1.2:
Рисунок 1.2 – Схема алгоритма программы
Для разработки схемы алгоритма программы допускается использовать любое программное средство, предоставляющее соответствующие возможности, в том числе Diagram Designer, MS Word, MS Visio.
6) Текст программы.
Должен быть представлен полный текст разработанной программы. В том случае, если весь текст программы целиком вмещается в окне Turbo Pascal, допускается привести в отчете скриншот данного окна. Текст программы должен удовлетворять требованиям к программе (п. 1.3). Необходимо обеспечить выравнивание операторов в тексте программы. Для лабораторной работы №1 ключевые слова program, const, var, begin, end не должны иметь отступов от левого края, а все остальные строки кода должны иметь отступ от левого края – 2 пробела (см. п. 1.8).
7) Входные данные и результаты работы программы.
Привести скриншот окна Turbo Pascal с результатами работы программы. Для получения скриншота можно воспользоваться клавишами Alt+PrintScreen
8) Ответы на контрольные вопросы.
Письменно кратко ответить на контрольные вопросы.
9) Выводы по проделанной работе.
Привести выводы по результатам выполненной лабораторной работы. Выводы – это краткое отражение наиболее значимых результатов выполненной работы. Для лабораторных работ допускаются выводы, совпадающие с основными положениями, приведенными в пункте «Цель работы».
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?
Приобретение навыков разработки программ разветвленной структуры на языке Pascal с использованием операторов условного перехода IF, выбора CASE и безусловного перехода GOTO. Получение навыков использования встроенного отладчика.
1. Освоить основные функции встроенного отладчика интегрированной среды Turbo Pascal (п. 2.5).
2. Разработать программу с разветвленной структурой в соответствии с предложенным вариантом. Ввод данных, вычисления и вывод результатов организовать в диалоговом режиме с использованием оператора CASE (п. 2.7).
Программа должна выполнять следующие действия:
– вывод номера варианта и сообщения о назначении программы;
– вывод фамилии и инициалов автора программы;
– вывод меню;
– ввод данных;
– вычисления и вывод результатов.
Результаты работы выводятся в отформатированном виде (с указанием количества знаков после десятичной точки).
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).
Очень часто при разработке программ возникает ситуация, при которой программа компилируется и запускается без ошибок, но в дальнейшем она выдает совершенно другой результат, нежели от нее ожидал программист. Это свидетельствует о том, что программист допустил логическую ошибку. Примеры логических ошибок:
– вместо 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 перейдет в режим отладки, в котором можно совершать все действия, упомянутые ранее.
При разработке любой программы необходим механизм, позволяющий выполнить тот или иной участок программного кода, основываясь на некотором условии. Для реализации такого рода алгоритмов в 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, расположенному выше по коду.
Перед тем, как познакомиться с оператором 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 кВт/час }
В том случае, если задана некоторая переменная порядкового типа (целочисленная, логическая или символьная) и на каждое возможное ее значение программа должна отреагировать индивидуально, рекомендуется использовать оператор выбора 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 (строка).
Оператор безусловного перехода 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 следует применять другие методы, например циклы и подпрограммы (см. следующие лабораторные работы).
Составить программу вычисления функции:
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 Flag then {Если пункт №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).
Обратите внимание на выравнивание операторов в приведенных примерах! Очень легко поддается пониманию программа, в которой все операторы выровнены надлежащим образом.
Представьте, что в предыдущем примере не было произведено выравнивание операторов, например:
case n of
1:........
2:
begin
if not Flag then
Writeln ('Данные не введены, выполните пункт №1');
else
begin
if X > 0 then
Y := 1 / X
else
Y := X * X;
Writeln('При X = ', X:7:2, ' Y = ', Y:7:2);
end;
end;
3: Exit;
end;
В таком виде разобраться с данным примером практически невозможно. Выравнивание должно быть выполнено таким образом, чтобы вложенные группы операторов имели отступ вправо относительно внешних операторов (рекомендуется 2 пробела). Помните, что каждый BEGIN должен иметь завершающий END, причем их следует располагать на одной вертикальной линии. Все, что находится внутри операторных скобок BEGIN..END, должно смещаться вправо.
1) Вычислить объем параллелепипеда со сторонами A, B, C и определить, является ли данное геометрическое тело кубом.
2) Вычислить площадь треугольника со сторонами А, В, С. Перед вычислением площади проверить условие существования треугольника с заданными сторонами.
3) Вычислить площадь треугольника со сторонами A, B, C. Определить, является ли треугольник равнобедренным.
4) Вычислить площадь прямоугольника со сторонами A и B и определить, является ли данная фигура квадратом.
5) Составить программу нахождения корней квадратного уравнения у=ах2+bх+с.
6) Определить, можно ли сделать круглую заготовку с заданным радиусом R из квадратного листа фанеры с заданной стороной A.
7) Определить, хватит ли имеющейся суммы S на покупку N-го количества товара (при известной цене товара).
8) Определить, можно ли сделать две квадратных заготовки со стороной А из листа железа прямоугольной формы со сторонами В и С.
9) Определить, достаточно ли имеющейся ткани для изготовления изделий двух видов, если известны: расход ткани на каждое изделие, количество изделий каждого вида, количество имеющейся ткани.
10) Рассчитать сумму оплаты за потребленную энергию, если известны: стоимость 1 квт/час, расход энергии, коэффициент льгот (льготы могут отсутствовать).
11) Определить, достаточно ли бензина для поездки, если известны: длина пути, количество бензина в баке и расход бензина на 1 км.
12) Определить, будет ли начислена студенту стипендия по результатам экзаменов (стипендия начисляется, если все экзамены сданы на «хорошо» и «отлично»), если известны оценки по всем экзаменам.
13) Определить, будет ли зачислен абитуриент в студенты по результатам вступительных экзаменов, если известны: проходной балл; количество баллов, набранных абитуриентом по каждому экзамену.
14) Определить, изделия какой из двух групп товаров выгоднее сшить из одного рулона ткани, если известны: расход ткани на каждое изделие и цена готового изделия, количество метров в рулоне.
15) Определить, выполнен ли план по продаже товара за день, если известны: план продажи (в рублях), количество проданного товара и цена товара.
16) Определить, операции с какой из двух валют составили большую прибыль, если известны: курс продажи, количество продаж по каждой валюте.
17) Определить наибольшую выручку от продажи трех видов товаров, если известны: цена товара; количество проданных товаров каждого вида.
18) Определить количество корней уравнения y=ax2+bx+c.
19) Определить, является ли число А четным или нечетным.
20) Вычислить площадь треугольника со сторонами A, B, C и определить, является ли данный треугольник равносторонним.
1) Назначение, формы записи и порядок выполнения оператора IF.
2) Особенности использования вложенных условных операторов.
3) Каковы отличия оператора выбора CASE от оператора условия IF?
4) Какие правила должны выполняться при использовании оператора выбора CASE?
5) Назначение и особенности оператора безусловного перехода.
6) Для чего нужна отладка программы?
7) Как выполнять программу в пошаговом режиме?
8) Как поставить и как отменить точки останова?
9) Как выполнить программу «до курсора»?
10) Как открыть окно Watch?
11) Как внести переменную в окно Watch?
Целью работы является освоение процесса разработки циклических программ с заданным (известным) числом повторений на языке Pascal.
Разработать программу с использованием оператора цикла FOR, осуществляющую следующие действия:
а) Вычисление заданной величины (суммы N слагаемых, произведения N сомножителей и т.п.);
б) Обработка данных с использованием двумерных массивов.
Программа должна выводить:
– номер варианта, назначение программы и ФИО автора;
– меню выбора действия программы («а» или «б»); допускается сделать две отдельные программы без меню выбора;
– информационные сообщения о необходимости ввода данных;
– сообщение с результатами, полученными в ходе работы программы;
1) Получить вариант задания (п. 3.8).
2) Изучить принцип действия FOR при разработке циклических программ на языке Pascal (п. 3.5).
3) Составить и отладить программу вычисления заданной величины (суммы N слагаемых, произведения N сомножителей и т.п.) в соответствии с подпунктом «а» варианта задания.
4) Изучить основы работы с данными типа «массив» (ARRAY) на языке Pascal (п. 3.6).
5) Разработать и отладить программу обработки данных с использованием двумерных массивов в соответствии с подпунктом «б» варианта задания.
6) Объединить обе разработанные программы в одну с использованием меню выбора (п. 3.7).
7) Ответить на контрольные вопросы (п. 3.10).
8) Оформить отчет (см. п. 1.11)
Очень часто перед программистом стоит задача организовать работу программы таким образом, чтобы некоторый участок кода выполнялся многократно (с заданным количеством повторений). В языке Pascal для этой цели предусмотрен оператор FOR, имеющий 2 формы записи:
1) for I := N1 to N2 do <тело цикла>;
2) for I := N1 downto N2 do <тело цикла>;
Цикл FOR работает следующим образом. Вначале программа определяет значение переменных (выражений) N1 и N2. Далее переменная цикла I (счетчик цикла) получает начальное значение N1. После этого осуществляется сравнение переменной I с конечным значением N2 и если переменная I его не превышает (для первой формы FOR) либо если I больше или равно N2 (для второй формы FOR), то выполняется «тело цикла», т.е. заданный оператор (или группа операторов в BEGIN..END). После того, как тело цикла было выполнено, управление вновь переходит к оператору FOR, переменная I получает новое значение (на единицу больше, либо на единицу меньше, чем в прошлый раз), далее осуществляется ее сравнение с N2 и принимается решение о том, следует ли еще раз выполнить тело цикла.
Ниже представлены примеры для обеих форм оператора FOR. Программа осуществляет перемножение заданной переменной Num с текущим значением счетчика цикла J и выводит на экран результат вычисления выражения, порядковый номер итерации и значение счетчика цикла.
|
var Num, J: Integer; begin Num := 3; {объявляем цикл «вверх» от 1 до 5} for J := 1 to 5 do begin {Выводим результат умножения на экран } Writeln(J, ') ', Num, '*', J, '=', Num * J); {Выполняем умножение} Num := Num * J; end; end. |
Результаты: 1) 3*1=3 2) 3*2=6 3) 6*3=18 4) 18*4=72 5) 72*5=360 |
|
var Num, J, K: Integer; begin Num := 7; K := 1; {порядковый № итерации} {объявляем цикл «вниз» от 9 до 6} for J := 9 downto 6 do begin {Выводим результат умножения на экран} Writeln(K, ') ', Num, '*', J, '=', Num * J); {Выполняем умножение} Num := Num * J; K := K + 1; {Увеличиваем порядковый номер} end; end. |
Результаты: 1) 7*9=63 2) 63*8=504 3) 504*7=3528 4)3528*6=21168 |
Поскольку во втором примере используется оператор FOR с downto, а переменная J (счетчик цикла) изменяет свое значение от 9 до 6, то для определения порядкового номера итерации пришлось добавлять новую переменную «K». В первом примере этого не требовалось, поскольку счетчик цикла J изменяется от 1 до 5, а эти значения соответствуют номеру итерации.
Следующий пример демонстрирует использование цикла FOR для вычисления суммы (слева) и произведения (справа):
|
const n = 5; {Количество шагов} var I: Integer; Res, X: Real; begin X := 10; {Ввод Х} Res := 0; {Обнуление Res} for I := 1 to n do Res := Res + I * (X * X); Writeln('Res = ', Res:8:2); end. |
const n = 4; {Количество шагов} var I: Integer; Res, X: Real; begin X := 15; {Ввод Х} Res := 1; {Присвоение единицы} for I := 1 to n do Res := Res * (X + I * I * I); Writeln('Res = ', Res:8:2); end. |
При использовании оператора FOR необходимо учитывать следующие замечания:
– переменная цикла (счетчик числа), а также выражения N1 и N2 должны иметь порядковый тип. Дробный тип REAL не допускается. В большинстве случаев для объявления счетчика цикла используется тип INTEGER;
– внутри тела цикла запрещено изменение переменной цикла;
– значение переменной цикла является актуальным только внутри тела цикла; после завершения работы цикла значение переменной цикла является неопределенным, т.е. установленным случайным образом;
– переменную цикла можно использовать повторно, например, при программировании других циклов.
Следующий пример демонстрирует печать на экране участка функции косинуса Cos. При этом используются 2 цикла FOR: внешний (со счетчиком цикла I) и внутренний (со счетчиком цикла J):
|
program Cosinus; const Pi = 3.14159; {Константа Pi} {Границы внешнего цикла в градусах} MaxGradus = 90; var I, J: Integer; Rad, Value: Real; begin {Внешний цикл по I (от -90 до +90)} for I := -MaxGradus to MaxGradus do begin {Учитываются только градусы, кратные 5} if I mod 5 = 0 then begin {Пересчет градусов в радианы} Rad := Pi * I / 180; {Вычисление косинуса. В результате Value} {будет иметь значение от 0 до 1} Value := Cos(Rad);
{Внутренний (вложенный) цикл (по J)} {Печатает на экране от 1 до 20 пробелов} {Round округляет число до целого} for J := 1 to Round(Value * 20) do Write(' ');
{Печать символа «*»} Writeln('*'); end; end; Readln; {ожидание нажатия ENTER} end. |
Ниже представлены необходимые пояснения к данному примеру:
1) Переменная внешнего чикла I меняет на каждой итерации значение, начиная с –90 и заканчивая +90. Этот диапазон выбран не случайно, поскольку функция Cos будет иметь в этом диапазоне только положительные значения от 0 до 1.
2) Операция «mod» возвращает остаток от деления двух целых чисел. Условие «if I mod 5 = 0 then» будет выполнено только в том случае, если значения I кратны 5 (т.е. -90, -85, -80,…, -10, -5…0, 5, 10…, 85, 90). Таким образом, символ «*» будет печататься на экране не для каждого градуса. Это сделано для того, чтобы весь график косинуса поместился на экране. Вместо 180 символов «*» на экране печатается только 37 символов.
3) Cos – это функция, принимающая в качестве аргумента величину угла, выраженную в радианах, и возвращающая значение косинуса в диапазоне от –1 до +1. Перед вызовом функции «Cos» осуществляется преобразование градусов в радианы: Rad := Pi * I / 180.
4) В примере присутствует дополнительный цикл FOR со счетчиком J. Он расположен внутри тела другого цикла, т.е. является «вложенным» или «внутренним». Он служит для заполнения строки пробелами. В зависимости от вычисленного значения косинуса, внутренний цикл выполняется от нуля до 20 раз, т.к. переменная Value в данном примере может иметь значения от 0 до 1.
5) Для печати символа «*» используется оператор Writeln.
6) Оператор Readln, указанный в программе без скобок, приостанавливает программу до тех пор, пока пользователь не нажмет Enter. При этом никакого ввода данных не происходит. Это избавляет от необходимости нажимать Alt+F5 для просмотра результатов работы программы.
Важно отметить, что наименование переменной вложенного цикла должно отличаться от переменной внешнего цикла. Глубина вложенности циклов FOR может быть любой, однако на практике не приветствуется слишком большая вложенность, поскольку ухудшается читабельность кода. В таких случаях рекомендуется использовать методы процедурного программирования.
При необходимости можно досрочно прервать работу цикла. Для этого следует вызвать оператор Break. В том случае, если требуется пропустить операторы тела цикла и перейти к следующей итерации, следует вызвать оператор Continue. Не рекомендуется злоупотреблять оператором Continue, поскольку его использование ухудшает читабельность кода, тем более из любой ситуации можно выйти, не используя Continue. Оператор Break, вызванный из вложенного цикла, не прерывает работу внешнего цикла.
На рисунке 3.1 представлен пример участка схемы алгоритма, соответствующего циклу с известным числом повторений.
Рисунок 3.1 – Схема алгоритма участка программы с циклом for
Возведение в степень
В языке Pascal отсутствует операция возведения в степень. Для возведения любого числа в целую, положительную степень вы можете использовать следующий код:
{Пример демонстрирует возведение числа X в степень N}
program Stepen;
var
X, Res: Real;
N, I: Integer;
begin
{*** Ввод данных ***}
Write('Введите значения X и N:');
Readln(X, N);
{*** Возведение в степень ***}
Res := 1; {Присваиваем начальное значение переменной Res}
for I := 1 to N do {Цикл возведения в степень}
Res := Res * X;
{*** Вывод результата на экран ***}
Writeln('X^N=', Res:5:2);
end.
Цикл возведения в степень целесообразно применять, если значение степени заранее неизвестно.
Если требуется возвести число в квадрат или в куб, то проще поступить следующим образом: Y := X * X или Y := X * X * X.
Для возведения числа «–1» в целую, положительную степень рекомендуется следующий код:
if Odd(N) then {Если число нечетное... }
Y := –1
else {Иначе (если число четное)... }
Y := 1;
Odd – это функция, возвращающая логический результат True, если аргумент является нечетным числом, иначе возвращает False.
Массив — упорядоченный набор данных для хранения множества элементов одного типа, идентифицируемых с помощью одного или нескольких индексов. Количество используемых индексов массива может быть различным. Массивы с одним индексом называют одномерными, с двумя — двумерными и т.д. Одномерный массив соответствует вектору в математике, двумерный — матрице. Массивы с числом измерений > 2 встречаются редко.
Формат объявления переменных типа «массив» представлен ниже:
var
<список переменных> = array[<индексы>] of <тип данных>;
где <список переменных> – наименование одной или нескольких переменных (через запятую);
<индексы> – описание диапазона индексов для каждого измерения массива, например:
- [1..10] – соответствует одномерному массиву (вектору), первый элемент которого имеет индекс «1», а последний «10» (всего 10 элементов);
- [0..4] – соответствует одномерному массиву, первый элемент которого имеет индекс «0», а последний «4» (всего 5 элементов);
- [1..5, 1..4] – соответствует двухмерному массиву (матрице), состоящему из 5 строк (индексация от 1 до 5) и 4 столбцов (индексация от 1 до 4);
<тип данных> – любой тип данных, известный компилятору Pascal, например, Integer, Byte, Real, Boolean, Char, string, а также типы данных, объявленные программистом.
Ниже приведены примеры объявления переменных типа «массив»:
{2 вектора из 10 элементов типа Integer. Индексация начинается с «1»}
Vect1, Vect2: array[1..10] of Integer;
{Матрица вещественных чисел 8 х 6. Индексация начинается с «0»}
Matr: array[0..7, 0..5] of Real;
{Список из 20 строк. Индексация начинается с «1»}
StrList: array[1..20] of string;
Во многих случаях более удобным является однократное объявление типа данных «массив» в начале программы (в секции type). Объявленный таким способом тип данных в дальнейшем можно использовать при описании переменных. Данный способ имеет следующие преимущества:
- при необходимости внесения изменений в объявление массива достаточно это сделать в одном месте;
- переменные, объявленные в секции var с использованием отдельного типа, являются совместимыми, т.е. между ними допускается операция присвоения «:=»;
- при использовании в программе процедур и функций у программиста появляется возможность объявления параметров процедуры, имеющих тип «массив».
Ниже представлен пример объявления нового типа данных «массив», а также переменных этого типа:
type
{Объявление нового типа данных «матрица»}
TMatrix = array[1..10, 1..20] of Real;
var
{Объявление переменных типа TMatrix}
Matrix1, Matrix2, Matrix3: TMatrix;
.......................................
Для любого элемента массива можно узнать его текущее значение, а также записать новое значение. Каждый элемент массива имеет свои координаты, указать которые можно в квадратных скобках. Ниже приведены примеры чтения и записи элементов одномерного массива:
{Установка нового значения 3-го элемента вектора}
Vect[3] := 3.45; {Установка заданного числового значения}
Vect[3] := Random; {Установка случайного значения}
Readln(Vect[3]); {Значение вводится пользователем с клавиатуры}
{Чтение 2-го элемента вектора}
Value := Vect[2]; {Присвоение в переменную Value}
Writeln(Vect[2]); {Вывод на экран}
{Вычисление суммы первых трех элементов}
Summa := Vect[1] + Vect[2] + Vect[3];
Ниже приведены примеры чтения и записи элементов двухмерного массива (матрицы):
{Установка заданного значения элемента матрицы с координатами 4, 3}
{индекс 4 – это номер строки матрицы, 3 – номер столбца матрицы}
Matrix[4, 3] := 123.456;
Readln(Matrix[2, 4]); {Ввод элемента (2, 4) с клавиатуры}
Writeln(Matrix[I, J]); {Вывод элемента (I, J) на экран}
В качестве индекса элемента массива может выступать явно указанное целое значение, либо целочисленная переменная. Чаще всего обработка элементов массива выполняется в цикле, поэтому в качестве индекса используется переменная-счетчик цикла, например:
for I := 1 to 10 do {цикл по I от 1 до 10}
Vect[I] := Random; {I-му элементу присваивается случайное число}
В приведенном ниже примере осуществляется заполнение элементов матрицы случайными числами с помощью функции Random, вывод полученных значений на экран, также осуществляется поиск наибольшего значения и вывод его (вместе с координатами) на экран.
program FindMaxElement;
const {Объявление констант}
Rows = 5; {Число строк матрицы}
Cols = 4; {Число столбцов матрицы}
var
{Объявление массива размером Rows x Cols}
Mas: array[1..Rows, 1..Cols] of Real;
I, J: Integer; {Объявление переменных цикла}
MaxValue: Real; {Максимальное значение}
MaxRowIndex: Integer; {Номер строки максимального значения}
MaxColIndex: Integer; {Номер столбца максимального значения}
begin
{Цикл заполнения массива и вывода элементов на экран}
for I := 1 to Rows do {Цикл по I (перебор строк матрицы)}
begin {можно было обойтись и без этого begin..end }
for J := 1 to Cols do {Цикл по J (перебор столбцов матрицы)}
begin {а этот begin..end требуется обязательно}
{Присваиваем элементу (I, J) случайное значение}
Mas[I, J] := Random;
{Печатаем значение элемента (все - на одной строке)}
Write(Mas[I, J]:8:2, ' ');
if J = Cols then {Если это последний столбец, }
Writeln; {то осуществляем перевод строки}
end;
end; {Данный begin..end здесь - для улучшения читабельности кода}
{Перед началом поиска максимального значения переменная
MaxValue уже должна иметь любое значение, но это значение
не должно быть больше, чем элементы матрицы. Поэтому
достаточно взять в качестве первоначального значения
любой элемент матрицы Mas, например самый первый}
MaxValue := Mas[1, 1]; {Запоминаем первый элемент}
MaxRowIndex := 1; {Запоминаем номер строки 1-го элемента}
MaxColIndex := 1; {Запоминаем номер столбца 1-го элемента}
{Цикл поиска максимального элемента}
for I := 1 to Rows do {Цикл по I (перебор строк матрицы)}
for J := 1 to Cols do {Цикл по J (перебор столбцов матрицы)}
begin
{Если текущий элемент (I, J) больше, чем MaxValue,
то записываем этот элемент в MaxValue и сохраняем его координаты}
if Mas[I, J] > MaxValue then
begin
MaxValue := Mas[I, J];
MaxRowIndex := I;
MaxColIndex := J;
end;
end;
{Выводим найденные значения на экран}
Writeln('Max value=', MaxValue:8:2, '; Row=',
MaxRowIndex, '; Col=', MaxColIndex);
Readln;
end.
Данный пример весьма прост и снабжен подробными комментариями. Очень важно детально разобраться с данным примером, поскольку от этого зависит успешность выполнения задания из варианта (п. 3.8).
program Laba3;
label
M1; {Объявление метки безусловного перехода M1}
var
SubTask: Char; {Переменная типа Char (символ)}
{**** Здесь разместить дополнительные необходимые переменные ****}
begin
Writeln('Выберите одну из подзадач:');
Writeln('a – вычисление заданной величины в цикле');
Writeln('b – обработка элементов матрицы');
Writeln('e – выход из программы');
M1:
Write('Введите символ:');
Readln(SubTask); {Ожидаем ввод любого символа}
case SubTask of
'a', 'A':
begin {Если ввели букву "a" или "A", то выполнится эта ветка}
Writeln('a) – вычисление заданной величины в цикле');
{******* Здесь разместить операторы, необходимые
для выполнения подзадачи "а" *******}
end;
'b', 'B':
begin {Если ввели букву "b" или "B", то выполнится эта ветка}
Writeln('b) - обработка элементов матрицы ');
{******* Здесь разместить операторы, необходимые
для выполнения подзадачи "б" *******}
end;
'e', 'E':
begin {Если ввели английскую "e" или "E", то закрываем программу}
Exit;
end; {begin..end здесь указывать не обязательно}
else {Для этого ELSE (от CASE) не нужен дополнительный begin..end }
{Если ввели любой другой символ, то выполнится эта ветка}
Writeln('Введен недопустимый символ!');
Writeln('Вы должны повторить ввод!');
goto M1; {Переход на метку M1}
end;
Readln; {Ожидание нажатия Enter}
end.
Данный пример не должен вызывать вопросов, поскольку сочетает в себе элементы кода, которые были в достаточной степени разобраны в предыдущих лабораторных работах.
Следует отметить, что Char – порядковый тип данных, обеспечивающий представление 256 символов, в том числе цифр, знаков препинания, всех больших и малых букв латинского алфавита, а также одного дополнительного алфавита (например, кириллицы).
1.а) Вычислить n!
б) Определить количество элементов матрицы, значения которых не превышают заданное число.
2.а) Вычислить .
б) Найти минимальный элемент матрицы.
3.а) Вычислить .
б) Найти максимальный элемент матрицы.
4.а) Вычислить .
б) Поменять местами минимальный и максимальный элемент матрицы.
5.а) Вычислить .
б) Поменять местами два заданных элемента матрицы.
6.а) Вычислить .
б) Поменять местами две заданных строки матрицы.
7.а) Вычислить .
б) Транспонировать матрицу А.
8.а) Вычислить .
б) Сформировать массив В, содержащий сумму элементов каждого столбца матрицы А.
9.а) Вычислить .
б) Поменять местами два заданных столбца матрицы.
10.а) Вычислить .
б) Определить количество отрицательных элементов матрицы.
11.а) Вычислить
б) Определить количество положительных элементов матрицы.
12.а) Вычислить .
б) Вычислить среднее арифметическое элементов матрицы.
13.а) Вычислить .
б) Вычислить произведение отрицательных элементов матрицы.
14.а) Вычислить .
б) Вычислить сумму положительных элементов матрицы.
15.а) Вычислить .
б) Все отрицательные элементы матрицы возвести в квадрат.
16.а) Вычислить
б) Сформировать массив B, содержащий максимальные элементы строк матрицы A.
17.а) Вычислить .
б) Сформировать массив B, содержащий суммы элементов строк
матрицы A.
18.а) Вычислить сумму n членов геометрической прогрессии.
б) Вычислить сумму всех отрицательных элементов матрицы.
19.а) Вычислить .
б) Заполнить матрицу А случайными числами с помощью функции Random.
20.а) Вычислить .
б) Вычислить сумму элементов главной диагонали матрицы.
1) Каково назначение оператора цикла FOR?
2) Каковы правила записи оператора цикла FOR?
3) Каковы алгоритмы работы оператора цикла FOR?
4) Какие циклы называются вложенными?
5) Какие ограничения наложены на оператор FOR?
6) Как определяются данные типа «массив»? Запишите примеры определения данных типа массив с использованием разделов type и var (или только var).
7) Какой тип могут иметь имеет переменные, которые используются в качестве индексов массива?
8) Как получить доступ к элементам одно-, дву-, n-мерного массива?
9) Как можно организовать ввод (вывод) элементов одно-, дву, n-мерного массива?
Целью работы является освоение процесса разработки циклических программ с использованием условных циклов (с заранее неизвестным числом повторений) на языке Pascal.
Требуется разработать две программы (или одну с двумя циклами) с использованием операторов повтора (циклических операторов) WHILE и REPEAT.
Программа должна выводить:
– номер варианта, назначение программы и ФИО автора;
– информационные сообщения о необходимости ввода данных;
– сообщение с результатами, полученными в ходе работы программы;
Программа должна проверять допустимые значения аргумента при вычислениях, например, для избежания деления на ноль.
1. Получить вариант задания (п. 4.8).
2. Изучить правила использования операторов WHILE и REPEAT для разработки циклических программ (п. 4.6 и 4.7).
3. Определить область сходимости.
4. Составить и отладить программу вычисления суммы ряда с заданной точностью с использованием циклического оператора WHILE.
5. Составить и отладить программу вычисления суммы ряда с заданной точностью с использованием циклического оператора REPEAT.
6. Проследить с помощью средств отладки системы Turbo Pascal (п. 2.5) изменения значений переменных и результатов проверки условий продолжения (окончания) цикла.
7. Ответить на контрольные вопросы (п. 4.9).
8. Оформить отчет (см. п. 1.11).
Оператор REPEAT организует выполнение цикла с заранее неизвестным числом повторений. Тело цикла выполняется хотя бы один раз. Работа цикла прекращается, как только будет достигнуто условие выхода из цикла. Структура оператора REPEAT:
repeat
<Оператор 1>;
<Оператор 2>;
...
<Оператор N>;
until <Условие выхода из цикла>;
Поскольку ключевые слова REPEAT и UNTIL играю роль операторных скобок, то выполняемые между ними операторы не требуется размещать в дополнительном блоке BEGIN..END.
Алгоритм работы оператора REPEAT:
1) выполняются операторы, расположенные в теле цикла;
2) проверяется условие выхода из цикла: если результат логического выражения равен False (т.е. условие выхода из цикла еще не достигнуто) то тело цикло будет выполнено еще раз; если результат равен True (достигнуто условие выхода из цикла), то происходит выход из цикла, т.е. переход на следующий оператор.
Следует отметить, что в теле цикла должны тем или иным образом корректироваться значения переменных, участвующих в логическом условии выхода из цикла. В противном случае программа может «зациклиться» (зависнуть), т.е. выход из цикла не произойдет никогда и придется аварийно прервать работу программы.
На рисунке 4.1 приведена схема работы цикла REPEAT..UNTIL:
Рисунок 4.1 – Схема работы цикла repeat..until
В представленном ниже примере программа требует от пользователя ввести число, не равное нулю, т.е. осуществляет контроль правильности ввода данных.
program ControlInput;
var
X: Integer;
begin
repeat {Начало цикла REPEAT}
Write('Введите число X: ');
Readln(X);
if X = 0 then
Writeln('Ошибка! Вы ввели 0! Повторите ввод!');
until X <> 0; {Цикл закончится, если X не равен 0}
{Дальнейшие операторы...}
end.
В отличие от предыдущих примеров, в этом нет оператора GOTO.
Ниже представлен простой, но в то же время интересный пример использования оператора REPEAT. Вначале переменной Y присваивается некоторое значение, а затем в цикле переменная Y делится пополам и полученный результат записывается опять в Y. Цикл будет прерван после того, как в переменную Y будет записано значение «0».
program RepeatDivide;
var
Y: Real; {Дробная переменная}
Counter: Integer; {Счетчик}
begin
Counter := 0; {Обнуляем счетчик вначале программы}
Y := 10; {Присваиваем переменной Y начальное значение}
repeat {Начало цикла REPEAT}
Y := Y / 2; {Делим Y на 2 и присваиваем результат в Y}
Inc(Counter); {Увеличиваем счетчик на «1» (Counter := Counter + 1)}
until Y = 0; {Выход из цикла, если Y = 0}
Writeln('Y=', Y:16:14);
Writeln('Counter=', Counter);
Readln;
end.
На первый взгляд может показаться абсурдом то, что в качестве условия выхода из цикла используется выражение (Y = 0), ведь вначале программы было задано значение Y > 0, а деление Y на 2 никогда не даст «0». Но не следует забывать, что мы имеем дело с компьютерной программой, каждое число в которой имеет ограниченный диапазон значений, а дробные числа имеют конечную точность. В действительности условие (Y = 0) наступит уже через 132 итерации.
Ниже приведен пример вычисления суммы членов сходящегося числового ряда с заданной точностью α=0,0001. Смысл задачи заключается в том, что при увеличении целочисленного значения N происходит уменьшение значения функции . На рисунке 4.2 приведен соответствующий график зависимости:
Рисунок 4.2 – График зависимости выражения от числа n
На этом графике по оси абсцисс отложены значения числа N. Как видно, функция становится ≈ 0 уже при N = 22. Очевидно, что при дальнейшем увеличении N значение функции изменяться практически не будет. Согласно условию задачи, необходимо запрограммировать цикл суммирования членов ряда для 0 ≤ N < ∞. При этом цикл должен прерываться, как только результат функции окажется ≤ α. Ниже представлен листинг программы, соответствующий этой задаче:
program NumSeriesDemo;
const
Alpha = 0.0001;
var
N, I: Integer;
Sum, F: Real;
begin
Sum := 0; {Начальное значение суммы числового ряда}
N := 0; {Начальное значение числа N}
repeat {Начало цикла REPEAT}
{ Вычисляем функцию (-7/9)^n }
F := 1;
for I := 1 to N do {Цикл возведения в степень}
F := F * (-7/9);
Sum := Sum + F; {Выполняем суммирование}
N := N + 1; {Увеличиваем N на единицу}
until Abs(F) <= Alpha; {Условие выхода из цикла}
Writeln('Sum: ', Sum:15:8); {Выводим на экран сумму (0.5624)}
Writeln('N: ', N); {Выводим на экран количество итераций (38)}
Writeln('F: ', F:15:8); {Выводим на экран последнее значение F}
Readln; {Ожидаем нажатие ENTER}
end.
На экран программа выведет значение N=38. Это означает, что числовой ряд сходится с заданной точностью уже на 38-й итерации.
Следует отметить, что в Turbo Pascal отсутствует встроенная функция возведения в степень, поэтому в данном примере для этой цели был реализован дополнительный цикл FOR. Функция Abs отбрасывает знак «минус», т.е. возвращает модуль числа, его абсолютное значение.
Оператор цикла WHILE, аналогично циклу REPEAT, организует выполнение операторов тела цикла неизвестное заранее число раз. В начале каждой итерации осуществляется проверка заданного логического выражения (условия выполнения цикла), и если оно выполняется (равно True), то осуществляется переход к операторам тела цикла, в противном случае (False) работа цикла прекращается и осуществляется переход к операторам, расположенным после цикла. Структура оператора WHILE:
while <Условие выполнения цикла> do
begin
<Оператор 1>;
<Оператор 2>;
...
<Оператор N>;
end;
Следует отметить, что при наличии в теле цикла WHILE нескольких операторов, все они должны находиться внутри операторных скобок BEGIN..END.
Схема работы цикла WHILE приведена на рисунке 4.3:
Рисунок 4.3 – Схема работы цикла while
Цикл WHILE удобно применять в качестве замены цикла FOR в тех случаях, когда переменная (счетчик) цикла должна быть дробной (Real), либо требуется осуществлять модификацию переменной в теле цикла, либо значение переменной цикла должно изменяться с некоторым заданным шагом, что позволяет обойти ограничение цикла FOR, в котором переменная цикла всегда изменяется с шагом «1». В приведенном ниже примере вычисляется сумма всех чисел от 1 до N, с шагом K:
program WhileDemo;
var
N, K, I, Sum: Integer;
begin
Write('Введите N, K: ');
Readln(N, K);
Sum := 0; {Начальное значение суммы}
I := 1; {Начальное значение счетчика цикла}
while I <= N do {Условие выполнения тела цикла}
begin
Sum := Sum + I; {Вычисляем сумму}
I := I + K; {Изменяем счетчик цикла с заданным шагом}
end;
Writeln('Сумма: ', Sum);
end.
Очень часто программисты используют WHILE для организации «бесконечных» циклов: в качестве условия выполнения цикла явно указывают «True», а прерывание цикла реализуют с помощью Break с использованием одного либо нескольких дополнительных условий:
while True do
begin
Readln(N);
if N = 0 then Break;
{Прочие операторы цикла}
end;
Следующий пример демонстрирует вывод на экран последовательности чисел Фибоначчи, а также результат деления каждой пары полученных чисел. Последовательность этих чисел следующая: 1, 2, 3, 5, 8, 13, 21, 34, и т.д. Каждое очередное число получается как сумма двух предыдущих. При делении двух соседних чисел получается значение, которое стремится к 1,618 (34/21=1,619) или 0,618 (21/34=0,6176). Значение 1,618 называют пропорцией «золотого сечения», это «оптимальное» соотношение сторон, признак гармонии в природе. Ниже приведен текст программы:
program GoldenRatio;
var
N: Integer;
NewF, OldF: Integer; {Текущее и предыдущее числа}
Tmp: Integer; {Временная переменная}
begin
Write('Введите N: ');
Readln(N);
OldF := 1; {Предыдущее число = 1}
NewF := 2; {Текущее число = 2}
while NewF <= N do
begin
{Выводим текущее число Фибоначчи и "Золотое сечение"}
Writeln('F=', NewF, '; Golden ratio=', NewF/OldF:8:5);
Tmp := OldF; {Запоминаем предыдущее число}
OldF := NewF; {Запоминаем текущее число}
NewF := NewF + Tmp; {Вычисляем очередное число}
end;
Readln;
end.
|
№ варианта |
Общий член ряда |
Точность |
|
1 |
=0,01 |
|
|
2 |
=0,001 |
|
|
3 |
=0,01 |
|
|
4 |
=0,1 |
|
|
5 |
=0,01 |
|
|
6 |
=0,001 |
|
|
7 |
=0,0001 |
|
|
8 |
=0,1 |
|
|
9 |
=0,01 |
|
|
10 |
=0,001 |
|
|
11 |
=0,01 |
|
|
12 |
=0,1 |
|
|
13 |
=0,0001 |
|
|
14 |
=0,001 |
|
|
15 |
=0,001 |
|
|
16 |
=0,001 |
|
|
17 |
=0,001 |
|
|
18 |
=0,001 |
|
|
19 |
=0,01 |
|
|
20 |
=0,01 |
1. Каково назначение условных операторов повтора (циклов)?
2. Какие требования предъявляются к выражениям, управляющим повторениями?
3. В чем отличия операторов повтора WHILE и REPEAT?
4. В каких случаях предпочтительнее использовать для организации циклов оператор повтора FOR? Что записывается в заголовке этого оператора?
5. Какие правила пунктуации необходимо соблюдать при записи операторов?
6. Что такое вложенные циклы? Какие дополнительные условия необходимо соблюдать при организации вложенных циклов?
Приобретение навыков разработки программ с использованием процедур и функций пользователя на языке Pascal.
Разработать программу для вычисления значений функции в соответствии с вариантом задания и вывести результаты в табличном виде.
Программа должна выводить:
– номер варианта, назначение программы и ФИО автора;
– информационные сообщения о необходимости ввода данных;
– результаты работы программы в виде таблицы:
|
Значение функции в интервале [5..9] с шагом 0.1 |
|
|
Аргумент |
Функция |
|
X=<значение аргумента> |
Y=<значение функции от X> |
|
... |
... |
Программа должна состоять из основной части и двух подпрограмм:
1) процедура ввода данных (например, «Vvod»), требующая от пользователя ввести значения для формулы согласно варианту задания, например, A, B, C; программа не должна требовать от пользователя ввода значения X;
2) функция вычисления формулы (например, «CalcFormula») (п. 5.6).
Логика основной части программы должна быть построена из следующих элементов:
1) оператор вызова процедуры ввода данных, в объявлении которой перечислены параметры-переменные; данная процедура должна потребовать от пользователя ввода констант (например, A, B, C), за исключением X;
2) оператор цикла (по выбору: WHILE, REPEAT или FOR), в каждой итерации которого:
– наращивается значение переменной X (например, от 5 до 9 с шагом 0.1);
– осуществляется вызов функции вычисления формулы (например, «CalcFormula») с указанием аргумента X, а также остальных констант, при необходимости; результат вычисления формулы записывается в переменную Y;
– обе переменные X и Y выводятся на экран с помощью Writeln.
1) Получить вариант задания (п. 5.6). Варианты задания содержат данные о функции, начальном и конечном значении аргумента и шаге его приращения.
2) Изучить структуру Pascal-программы, содержащей процедуры и функции пользователя (п. 5.5).
3) Разработать программу в соответствие с заданием.
4) Выполнить отладку программы с заходом в каждую из подпрограмм (см. п. 2.5). Это позволит значительно укрепить знания как по процедурам и функциям, так и по отладке приложений.
5) Ответить на контрольные вопросы (п. 5.8).
6) Оформить отчет (см. п. 1.11).
В программировании очень часто применяют способ структурирования программного кода, основанный на использовании подпрограмм. Подпрограмма – это оформленный особым образом именованный участок кода, который можно запустить на выполнение из любого места программы. Таким образом, отпадает необходимость многократного дублирования одних и тех же действий в разных частях программы. Достаточно проанализировать то, как часто в программе выполняются те или иные действия, и наиболее часто используемые оформить в виде подпрограммы. В программе допускается любое количество подпрограмм.
Рассмотрим пример решения задачи «вычислить сумму xa + yb + zc, где x, y, x – любые числа; a, b, c – целые числа ≥ 0» без использования подпрограмм:
program PowerBadDemo;
var
X, Y, Z: Real; {Дробные числа (будут возводиться в степень)}
A, B, C: Integer; {Степени (целые числа)}
Xa, Yb, Zc: Real; {Результаты возведения в степень}
I: Integer; {Счетчик цикла возведения в степень}
begin
Writeln('Программа вычисления суммы x^a + y^b + z^c');
Write('Введите любые числа X, Y, Z: ');
Readln(X, Y, Z);
Write('Введите целые неотрицательные степени A, B, C: ');
Readln(A, B, C);
{ Цикл возведения числа X в степень A }
Xa := 1;
for I := 1 to A do
Xa := Xa * X;
{ Цикл возведения числа Y в степень B }
Yb := 1;
for I := 1 to B do
Yb := Yb * Y;
{ Цикл возведения числа Z в степень C }
Zc := 1;
for I := 1 to C do {Цикл возведения в степень C}
Zc := Zc * Z;
Writeln(Xa + Yb + Zc:8:2);
Readln;
end.
В данной программе для каждой операции возведения в степень используется отдельный цикл FOR. При этом пришлось объявить дополнительные переменные: I (счетчик чикла), а также Xa, Yb, Zc (промежуточные результаты возведения в цикл). Несложно представить, во что превратится программа вычисления суммы ua + vb + wc + xd + ye + zf. Она будет в два раза больше. При этом увеличивается вероятность ошибки, усложняется отладка программы. Представим, что будет, если изменится условие задачи и потребуется обработка не только положительных, но и отрицательных значений степени: придется вносить значительные исправления в каждом случае возведения в степень, при этом вероятность ошибки увеличивается многократно.
Та же самая задача может быть элегантно решена с применением подпрограммы:
program PowerGoodDemo; {Демонстрация более удачной программы}
{Power - это ФУНКЦИЯ возведения числа Value в степень Stepen }
function Power(Value: Real; Stepen: Integer): Real;
var {Объявление локальных переменных для работы функции}
I: Integer; {I - это ЛОКАЛЬНАЯ переменная}
TmpValue: Real; {TmpValue - временная переменная (тоже локальная)}
begin {Начало тела функции}
TmpValue := 1; {Инициализация временной переменной}
for I := 1 to Stepen do {Цикл возведения в степень Stepen}
TmpValue := TmpValue * Value;
{ИМЕНИ функции присваиваем результат работы функции}
Power := TmpValue;
end; {Конец тела функции. Она вернет результат, записанный в Power}
{*** НАЧАЛО ОСНОВНОЙ ЧАСТИ ПРОГРАММЫ ***}
var {Объявление переменных основной части программы}
X, Y, Z: Real; {Дробные числа (будут возводиться в степень)}
A, B, C: Integer; {Степени (целые числа)}
begin {Здесь программа начинает свою работу}
Writeln('Программа вычисления суммы x^a + y^b + z^c');
Write('Введите любые числа X, Y, Z: ');
Readln(X, Y, Z);
Write('Введите целые неотрицательные степени A, B, C: ');
Readln(A, B, C);
{Вычисления и вывод на экран}
Writeln(Power(X, A) + Power(Y, B) + Power(Z, C):8:2);
Readln;
end. {Конец программы}
В этом примере все действия, необходимые для возведения в степень, объединены в одну подпрограмму с именем «Power». Подпрограмма, так же как и любая простая программа на языке Pascal, имеет область объявления переменных «var» (кроме этого, допустимы разделы «type», «const», «label»), а также тело подпрограммы, содержащее необходимые операторы, расположенные внутри BEGIN..END. Любая подпрограмма должна иметь наименование, в данном случае Power. Подпрограмма в этом примере объявлена следующим образом:
function Power(Value: Real; Stepen: Integer): Real;
Здесь указаны: тип подпрограммы («function», т.е. является функцией, значит должна возвращать некоторое значение-результат), параметры вызова подпрограммы (Value, Stepen) с указанием их типа, а также тип результата, возвращаемого функцией (Real).
Вызов функции осуществляется путем указания ее имени и передаваемых значений (аргументов) в круглых скобках. Пример вызова функции Power:
Res := Power(5, 2);
При этом будет вызвана функция Power; значение «5» будет автоматически записано в параметр Value, значение «2» – в параметр Stepen, после чего в теле функции аргументы Value и Stepen можно использовать как обычные переменные.
Функция должна обязательно возвращать какое-нибудь значение. В данном примере сначала используется временная переменная TmpValue, но перед окончанием работы функции значение данной переменной присваивается имени функции:
Power := TmpValue;
Тем самым, был определен результат работы функции. Если этого не сделать, то функция все равно вернет некоторый результат, но это будет непредсказуемое (случайное) числовое значение.
После вызова функции Power(5, 2), в переменную Res будет записан результат «25».
Поскольку функция возвращает значение, ее вызов может находиться справа от оператора присваивания «:=» (но не слева).
При выполнении оператора
Writeln(Power(X, A) + Power(Y, B) + Power(Z, C));
программа 3 раза вызовет функцию Power с указанными аргументами, просуммирует результаты и выведет полученную сумму на экран.
Анализ приведенного выше примера позволяет утверждать, что применение подпрограммы позволило сделать код более компактным, понятным, простым и удобным в сопровождении. При необходимости внесения изменений достаточно сделать это в одном месте. Разработанную функцию можно вызвать из любого места программы.
Подпрограмма, возвращающая значение-результат, называется функцией. Функция, состоит из заголовка и тела. Заголовок содержит зарезервированное слово «function», идентификатор (имя) функции, необязательный список формальных параметров, заключенный в круглые скобки и тип возвращаемого функцией значения. Тело функции представляет собой блок операторов, заключенный в BEGIN..END:
function <имя>(<список формальных параметров>): <тип результата>;
const ... {объявление констант, используемых в функции}
var ... {локальные переменные функции}
begin
<операторы>
end;
где <имя> – любой допустимый идентификатор, например, Func1;
<список формальных параметров> – список имен переменных и их типов, разделенных точкой с запятой «;», например (Value: Real; Stepen: Integer);
Важно! Имена переменных, перечисленные в списке формальных параметров, не обязаны совпадать с именами переменных, указанных при вызове подпрограммы. Подпрограмма может вызываться из нескольких различных мест программы, причем в каждом случае переменные могут называться по-разному. В рассмотренном примере для функции «Power» были объявлены параметры «Value» и «Stepen», однако при ее вызове использовались разные переменные: X, Y, Z, A, B, C. Более того, при вызове функции можно указывать непосредственные значения, например, Power(5, 2). В любом случае передаваемые в функцию значения будут скопированы в соответствующие формальные параметры, с которыми будет осуществляться дальнейшая работа (исключением является использование формальных параметров-переменных).
<тип результата> – тип возвращаемого функцией результата, например, Integer, Real и т.д.
Среди входящих в функцию операторов должен обязательно присутствовать как минимум один оператор присваивания «:=», в левой части которого указано имя данной функции, а в правой – значение-результат. В точку вызова возвращается результат последнего присваивания.
Подпрограмма, которая не возвращает значение-результат, называется процедурой (в терминологии языка Pascal). Процедура, состоит из заголовка и тела. Заголовок содержит зарезервированное слово «procedure», идентификатор (имя) процедуры и необязательный список формальных параметров, заключенный в круглые скобки. Тело процедуры представляет собой блок операторов, заключенный в BEGIN..END:
procedure <имя>(<список формальных параметров>);
const ... {объявление констант, используемых в процедуры}
var ... {локальные переменные процедуры}
begin
<операторы>
end;
Следующий пример демонстрирует использование процедуры для ввода двух значений A и B, где A > 0 (Real), B <> 0 (Integer). В процедуре «InputAB» организован контроль правильности вводимых данных. Для выхода из программы требуется, чтобы произведение двух чисел было равно 100.
program ProcDemo;
{ InputAB – процедура для ввода двух чисел. ValueA и ValueB – параметры-
переменные, поэтому в момент вызова процедуры InputAB в нее будут
переданы непосредственно сами переменные A и B, а не их копия }
procedure InputAB(var ValueA: Real; var ValueB: Integer);
begin
repeat
Write('Введите значение A (любое положительное число): ');
Readln(ValueA);
if ValueA <= 0 then
Writeln('Ошибка! Число должно быть > 0. Повторите ввод!');
until ValueA > 0;
repeat
Write('Введите значение B (целое ненулевое число): ');
Readln(ValueB);
if ValueB = 0 then
Writeln('Ошибка! Число не может быть = 0. Повторите ввод!');
until ValueB <> 0;
end;
var
A: Real;
B: Integer;
begin
repeat {Начало цикла REPEAT}
InputAB(A, B); {Вызов процедуры InputAB}
Writeln('Произведение A * B = ', A * B:8:2);
until A * B = 100; {Условие завершения цикла REPEAT}
end.
Особенностью данного примера является то, что в процедуре «InputAB» формальные параметры «ValueA» и «ValueB» являются параметрами-переменными (используется ключевое слово «var»), поэтому в момент вызова процедуры «InputAB» в нее будут переданы непосредственно сами переменные «A» и «B», а не их копия. Любое изменение формальных параметров «ValueA» и «ValueB» внутри процедуры приведет к тому, что будут изменены переменные «A» и «B».
Следующий простой пример демонстрирует вывод на экран информации о разработчике программы с помощью процедуры About:
program ProcDemo2;
procedure About; {Процедура объявлена без параметров}
begin
Writeln('Программа для демонстрации процедуры без параметров');
Writeln('Автор программы: Иванов И.И.');
Writeln('Версия программы: 1.0');
end;
begin
About;
{Прочие операторы программы}
end.
В данном случае процедура About не имеет параметров, поскольку они не требуются. Выполненная в этом примере структуризация программного кода позволила вынести часть кода из основной программы в процедуру, тем самым позволив автору программы сосредоточиться на более важных проблемах.
Переменные, перечисленные в заголовке подпрограммы, называются «формальными параметрами», в языке Pascal они отделяются друг от друга точкой с запятой «;». Формальные параметры получают фактические значения аргументов в момент вызова подпрограммы. Существуют 2 основных способа передачи аргумента в подпрограмму: «по значению» (с использованием параметров-значений) и «по ссылке» (с использованием параметров-переменных).
В случае использования параметров-значений (способ «передача по значению») происходит копирование передаваемого значения аргумента в соответствующий формальный параметр. Присвоение нового значения параметру в теле подпрограммы не может привести к изменению переменной, указанной при вызове подпрограммы. При вызове подпрограммы допускается указывать константы, как именованные, так и заданные явным образом. Пример объявления процедуры с передачей «по значению»:
procedure MyProc(MyParam: Integer); {MyParam - параметр-значение}
begin
...
end.
В случае использования параметров-переменных (способ «передача по ссылке») в подпрограмму передается непосредственно сама переменная-аргумент, а не ее копия. Присвоение нового значения параметру-переменной в теле подпрограммы приведет к изменению переменной, указанной при вызове подпрограммы. Тип параметров-переменных должен совпадать с типом переменных, которые указываются при вызове подпрограммы.
Ниже представлен пример вызова процедуры, в которой «MyParam» является параметром-переменной (используется ключевое слово «var»):
procedure MyProc(var MyParam: Integer); {MyParam - параметр-переменная}
begin
MyParam := MyParam * 2; {изменяем значение параметра MyParam}
end;
var
A: Integer;
begin
A := 5;
Writeln(A); {Будет напечатано значение "5"}
MyProc(A); {Вызов процедуры MyProc}
Writeln(A); {Будет напечатано значение "10"}
end.
Следует отметить, что в подпрограмме могут одновременно быть объявлены и параметры-значения и параметры-переменные, например:
procedure MyProc(A, B: Integer; var X: Real; C: Real; var Y: Integer);
В данном примере A, B, C являются параметрами-значениями, а X, Y являются параметрами-переменными.
Переменные, описанные внутри процедур и функций, называются локальными. Они создаются при каждом вызове подпрограммы и уничтожаются при выходе из нее, т.е. локальные переменные существуют только при выполнении подпрограммы и недоступны в основной программе. К локальной переменной в языке Pascal возможен доступ из любого участка подпрограммы, в которой объявлена эта переменная. Если в подпрограмме имеются вложенные подпрограммы (допускается любой уровень вложенности), то все они могут иметь доступ к данной переменной, кроме случаев, когда объявление переменной находится ниже, чем код подпрограммы.
Переменные, объявленные в основной программе, называются глобальными. К ним существует доступ не только из основной программы, но и из любой процедуры или функции, за исключением случаев, когда объявление глобальной переменной находится ниже, чем код подпрограммы.
Количество обращений к глобальным переменным из подпрограмм должно быть минимальным, поскольку это ухудшает читабельность кода, а также усложняет отладку и исправление ошибок.
Подпрограмму (допустим, A) можно вызвать не только из основной программы, но и из любой другой подпрограммы (допустим, B) при условии, что объявление подпрограммы A расположено выше, чем объявление подпрограммы B. В действительности данное условие не всегда является выполнимым. Обычно ограничения связаны с обеспечением более наглядной логической структуры программы, например, требуется, чтобы вначале располагались все подпрограммы, ответственные за ввод данных, за ними следовали подпрограммы, обеспечивающие все необходимые вычисления, а подпрограммы вывода результатов на экран располагались после всех предыдущих. Как в таком случае из подпрограммы ввода данных вызвать подпрограмму для проведения вычислений (ведь она расположена ниже)? Для разрешения подобных ситуаций применяется предварительное описание подпрограммы. В языке Pascal для предварительного описания подпрограммы вместо тела подпрограммы указывается ключевое слово «forward». Пример:
procedure ProcA(S: string); forward; {Предварительное описание }
procedure ProcB(S: string);
begin
ProcA(S); {Процедура ProcA объявлена выше, поэтому ошибки не будет}
end;
procedure ProcA; {Параметры не обязательно указывать еще раз }
begin
Writeln(S); {Будет напечатана строка «Hello!»}
end;
begin {Начало основной программы}
ProcB('Hello!'); {Вызываем процедуру ProcB с аргументом 'Hello!' }
end.
Вызов некоторой подпрограммы из той же самой подпрограммы называется рекурсивным, а последовательность нескольких таких вызовов – рекурсией. При программировании рекурсии важно предусмотреть критерий, завершающий цепочку рекурсивных вызовов, в противном случае рекурсия может оказаться бесконечной (в реальности программа будет аварийно завершать свою работу с ошибкой «переполнение стека»). На практике рекурсия чаще всего используется для обработки элементов древообразных (ветвящихся) структур, в которых невозможно заранее предугадать глубину ветвления.
|
№ варианта |
Функция |
Начальное значение |
Шаг |
Конечное значение |
|
1 |
1 |
0,1 |
3 |
|
|
2 |
2 |
0,2 |
4 |
|
|
3 |
3 |
0,5 |
5 |
|
|
4 |
4 |
0,1 |
6 |
|
|
5 |
5 |
0,2 |
7 |
|
|
6 |
6 |
0,5 |
8 |
|
|
7 |
7 |
0,1 |
9 |
|
|
8 |
8 |
0,2 |
10 |
|
|
9 |
9 |
0,5 |
11 |
|
|
10 |
10 |
0,1 |
12 |
|
|
11 |
11 |
0,2 |
13 |
|
|
12 |
12 |
0,5 |
14 |
|
|
13 |
13 |
0,1 |
15 |
|
|
14 |
14 |
0,2 |
16 |
|
|
15 |
15 |
0,5 |
17 |
|
|
16 |
16 |
0,1 |
18 |
|
|
17 |
17 |
0,2 |
19 |
|
|
18 |
18 |
0,5 |
20 |
|
|
19 |
19 |
0,1 |
21 |
|
|
20 |
20 |
0,5 |
22 |
1) Что называется подпрограммой?
2) Какова структура программы с подпрограммами?
3) Какова структура подпрограммы-процедуры?
4) Какова структура подпрограммы-функции?
5) В чем состоит различие и сходство процедур и функций?
6) Как осуществляется вызов процедур и функций?
7) Что называется параметром и каково его назначение?
8) Каково назначение формальных и фактических параметров и какова их взаимосвязь?
9) Опишите последовательность событий при вызове процедур или функций.
10) Для чего при отладке используется пошаговый режим с заходом в подпрограммы и как его осуществить?
11) В чем разница между способами передачи аргументов в подпрограмму «по значению» и «по ссылке»?
12) Чем отличаются локальные и глобальные переменные? Какова их область действия?
Приобретение навыков обработки символьных данных на языке Pascal.
Составить программу обработки символьных данных в соответствии с вариантом задания (п. 6.7).
Программа должна выводить:
– номер варианта, назначение программы и ФИО автора;
– информационные сообщения о необходимости ввода данных;
– результаты работы в соответствии с вариантом задания. Обработка символьных данных должна выполняться в подпрограмме пользователя (п. 6.6).
1) Получить вариант задания (п. 6.7).
2) Изучить операторы объявления и обработки символов и строк (п. 6.5).
3) Разработать и отладить программу обработки символьных данных.
4) Ответить на контрольные вопросы (п. 6.9).
5) Оформить отчет (см. п. 1.10).
Символьный тип обеспечивает программисту возможность работы с символами, к которым относятся: цифры (от 0 до 9), буквы латинского алфавита (как строчные, так и прописные), буквы национального алфавита (как строчные, так и прописные), знаки препинания и др. В связи с тем, что элемент, объявленный как Char, занимает в памяти 8 бит (1 байт), то всего доступно 256 символов. Каждый символ имеет собственный числовой код (от 0 до 255), причем коды от 0 до 127 являются стандартными (соответствуют американскому стандарту ANSI). Коды этих символов одинаковы практически в любых устройствах, компьютерах, операционных системах, языках программирования, Unicode-кодировках и т.д.
Значения от 128 до 255 предназначены для кодирования символов из других национальных алфавитов (в том числе кириллицы). Поскольку этого числового пространства хватает на кодирование алфавита лишь одного языка, то оперировать одновременно несколькими национальными алфавитами не представляется возможным. Более того, существуют языки, содержащие в алфавите свыше 127 символов (например, китайский, в котором более 50 тыс. иероглифов), поэтому использовать стандартные средства языка Pascal для работы с такими алфавитами весьма затруднительно.
Представляемые типом Char символы (в том числе кириллица) и их коды приведены на рисунке 6.1.
Рисунок 6.1 – Символы и их коды
Особое значение имеют символы с кодами:
– 9 – код символа табуляции. Используется для выравнивания текста. Осуществляет смещение курсора вправо на одну или несколько (но не более 8) позиций в зависимости от текущего расположения курсора. Новое положение курсора будет кратно 8 плюс 1.
– 10 – код перевода строки. В результате следующие символы будут напечатаны на новой строке.
– 13 – код возврата каретки. Возвращает курсор ввода на начало строки. Новые символы будут затирать предыдущие.
– 32 – код пробела.
Ниже представлен текст программы, с помощью которой был подготовлен рисунок 6.1:
var
I: Integer; {Объявление счетчика цикла FOR }
C: Char; {Объявление переменной «символ»}
begin
WriteLn('Перечень символов и их кодов:');
for I := 0 to 255 do {Цикл перебора всех кодов символов}
begin
C := Chr(I); {Получаем символ из его кода}
Write(I:3, ':', C, ' '); {Печать на экране символа и его кода}
if I mod 12 = 0 then {Если код символа кратный 12,}
WriteLn; {то переходим на следующую строку}
end;
end.
Значение переменной Char можно задать также с помощью оператора Readln, либо путем непосредственного присвоения отдельного символа (символьной константы), заключенного в одинарные кавычки (апострофы), например:
C := 'F';
Поскольку тип Char является порядковым, допускается использование по отношению к нему операций сравнения, например:
if (C >= 'A') and (C <= 'Z') then
Writeln('Это символ из латинского алфавита!');
Стандартные функции языка Pascal, применимые к типу Char, представлены к таблице 6.1.
Таблица 6.1 – Стандартные функции Pascal для работы с символами
|
Функция |
Назначение |
Тип аргумента |
Тип функции |
Пример |
|
Chr |
Получение символа по его коду |
Byte |
Char |
x := 68; y := Chr(2*x-5); {y='Г'} |
|
Ord |
Определение кода символа |
Char |
Byte |
x := 'G'; |
|
Pred |
Возвращение предыдущего символа |
Char |
Char |
x := 'Б'; |
|
Succ |
Возвращение следующего символа |
Char |
Char |
x := 'Г'; |
|
Upcase |
Преобразование строчной буквы в прописную |
Char |
Char |
Ch := 'd'; Y := Upcase(Ch); {Y='D'} |
Последовательность нескольких символов, расположенных друг за другом, образует строку. В общем случае, в строке может присутствовать произвольное количество символов, в том числе, ни одного. В случае языка Pascal, максимальная длина одной строки ограничена 255 символами. В современных языках программирования подобные ограничения, как правило, отсутствуют. Для объявления строки в языке Pascal служит ключевое слово STRING. Примеры объявления строки и присвоения строковых значений:
const
sConstStr = 'Строка 1'; {Объявление именованной константы}
var
S1: string; {объявление строки максимальной длины 255 символов}
S2: string[10]; {объявление строки длиной 10 символов}
S3: string[8]; {объявление строки длиной 8 символов}
begin
S1 := 'А роза упала на лапу Азора'; {присвоение строковой константы}
Readln(S2); {Строку должен ввести пользователь}
S3 := sConstStr; {присвоение именованной строковой константы}
end;
Для определения количества символов в строке служит функция Length:
Writeln(Length(S1)); {В нашем случае напечатает значение 26}
В языке Pascal существует второй способ определения длины строки – обращение к «нулевому» символу, например:
StrLen := Ord(S1[0]); {Присвоит в переменную StrLen значение 26}
Однако, поскольку второй способ специфичен для языка Pascal и не принят в других языках программирования, рекомендуется первый способ.
С помощью нулевого символа можно также изменить длину строки:
S1[0] := Chr(Length(S1) - 1); {Уменьшает длину строки на 1 символ}
Поскольку строки состоят из символов, а каждый символ имеет свой числовой код, то по отношению к строкам можно применять операции сравнения, например:
if S1 = 'hello' then
Writeln('Строки одинаковые')
else
Writeln('Строки разные');
Кроме того, допустимы операции <> (не равно), > (больше), >= (больше или равно), < (меньше), <= (меньше или равно). В практическом программировании при сравнении строк используют только операции = или <>.
Операция сравнения ('Hello' > 'hello') вернет False, поскольку код символа 'H' (72) меньше, чем код символа 'h' (104). Если бы эти символы оказались одинаковыми, то программа бы продолжила сравнение оставшихся символов.
Для объединения двух или более строк в одну служит операция сцепления «+», например:
S2 := 'Новый';
S3 := 'Год';
S1 := S2 + ' ' + S3; {Соединяем строки S2 и S3 через пробел }
Writeln(S1); {Напечатает строку: Новый Год}
Обращение к отдельному символу строки осуществляется по индексу (аналогично работе с массивами), например:
St[1] := 'F'; {В первый символ строки будет записано «F»}
Writeln(St[2]); {Печать на экране второго символа строки}
Информация о процедурах и функциях языка Pascal, применяемых для обработки строк, приведена в таблице 6.2
Таблица 6.2 – Процедуры и функции обработки строк
|
Заголовок |
Назначение |
Пример |
|
procedure Delete( var S: string; Index: Integer; Count: Integer); |
Удаление Count символов строки S, начиная с позиции Index |
S := 'абвгде'; Delete(S, 4, 2); {St='абве'} |
|
procedure Insert( Source: string; var S: string; Index: Integer); |
Вставка подстроки Source в строку S, начиная с позиции Index |
St1 := 'абвгде'; Insert('*', St1, 4); {Str2='абв*где'} |
|
procedure Str( X: Real; var S: string); |
Преобразует числовое значение величины X (Integer или Real) в строку и помещает результат в S |
V := 1500; Str(V:6, St); {St:=' 1500'} |
|
procedure Val( S: string; var V: Real; var Code: Integer); |
Преобразует строку S в ее числовое представление и помещает результат в V (Integer или Real) величину. Параметр Code возвращает код ошибки |
St := '1.455'; Val(St, V, Cod); {V=1.455, Cod=0} |
|
function Copy( S: string; Index, Count: Integer): string; |
Возвращает заданный участок строки S длиной Count символов, начиная с позиции Index. Если значение Count слишком большое, то возвращает символы до конца строки. |
St := 'абвгде'; Y := Copy(St, 2, 3); {Y='бвг'} |
|
function Pos( Substr, S: string): Integer; |
Отыскивает подстроку Substr в строке S и возвращает позицию первого символа найденной подстроки, либо ноль, если подстрока не найдена |
St2 := 'abcdef'; Y := Pos('de', St2); {Y=4} |
Приведенный ниже пример демонстрирует программу для упорядочивания по алфавиту ФИО, заданных в строке S:
program SortFIO;
type {Объявлям пользовательские типы TFIOElem и TFIOArray}
TFIOElem = string[40]; {Элемент массива с Ф.И.О.}
{Тип - массив из 10 строк, каждая длиной до 40 символов: }
TFIOArray = array[1..10] of TFIOElem;
{Сортировка строковых элементов массива самым простым способом}
{Используется алгоритм "Сортировка выбором"}
procedure DoSortArray(FioCount: Integer; var FioArray: TFIOArray);
var
I, J: Integer;
STmp: TFIOElem;
MinStrIdx: Integer;
begin
for I := 1 to FioCount - 1 do {Внешний цикл перебора слева-направо}
begin
MinStrIdx := I; {Пока считаем i-ый элемент минимальным}
{Отыскиваем строку, которая должна располагаться раньше по алфавиту}
for J := I + 1 to FioCount do {Внутренний цикл перебора}
if FioArray[J] < FioArray[MinStrIdx] then
MinStrIdx := J; {Запоминаем индекс найденной строки}
{Если такая строка найдена, то меняем ее с i-ым элементом}
if MinStrIdx <> I then
begin
STmp := FioArray[I]; {Запоминаем i-ый элемент}
{Записываем в него новое значение}
FioArray[I] := FioArray[MinStrIdx];
FioArray[MinStrIdx] := STmp;
end;
end;
end; {END of DoSortArray}
{Процедура MakeSort осуществляет сортировку строки с Ф.И.О.,
заданной с помощью аргумента St }
procedure MakeSort(var St: string);
var
{Объявляем массив из 10 строк, каждая длиной до 40 символов}
StrAr: TFIOArray;
I, Len, CurArIdx: Integer;
begin
{Заменяем все последовательности ", " на ","}
while Pos(', ', St) > 0 do
Delete(St, Pos(', ', St) + 1, 1);
Len := Length(St); {Запоминаем длину строки}
I := 1; {Инициализируем счетчик цикла WHILE}
CurArIdx := 1; {Инициализируем счетчик текущего элемента массива}
StrAr[CurArIdx] := ''; {Предварительная очистка строки}
{В цикле осуществляем разбивку исходной строки. В результате этого
каждое Ф.И.О. будет храниться в отдельном элементе массива StrAr,
а в переменную CurArIdx будет записано общее количество Ф.И.О.}
while I <= Len do {Пока не достигнут конец строки}
begin
if St[I] = ',' then {Если встретили запятую}
begin
Inc(CurArIdx); {Делаем текущим следующий элемент массива}
StrAr[CurArIdx] := ''; {Предварительная очистка строки}
end
else {Добавляем символ к текущему строковому элементу массива}
StrAr[CurArIdx] := StrAr[CurArIdx] + St[I];
Inc(I); {Увеличиваем счетчик цикла на единицу}
end; {Конец цикла WHILE}
{Выводим на экран промежуточные результаты работы программы
- список всех найденных Ф.И.О., каждое на отдельной строке}
for I := 1 to CurArIdx do
Writeln('FIO ', I, ': ', StrAr[I]);
{Сортировка элементов строкового массива}
DoSortArray(CurArIdx, StrAr);
St := ''; {Очищаем строку St}
{Записываем в var-параметр St отсортированный список Ф.И.О.}
for I := 1 to CurArIdx do
begin
St := St + StrAr[I]; {Выполняем "сцепление" строк}
if I < CurArIdx then {Если Ф.И.О. не последнее}
St := St + ', '; {то добавляем после него ", "}
end;
end; {END of MakeSort}
var
S: string;
begin {Начало основной программы}
Writeln('Введите несколько Ф.И.О. через запятую:');
Readln(S); {Ввод строки}
MakeSort(S); {Обработка строки (сортировка Ф.И.О.)}
Writeln('Список Ф.И.О. после сортировки:');
Writeln(S); {Вывод результатов на экран}
Readln;
end.
Количество слов в строке и максимальный размер каждого их слов выбираются студентом. Рекомендуется работать с латинскими символами.
1) Поменять местами слова с максимальной и минимальной длиной при выполнения условия, что такие слова единственные
2) Заменить окончания (последние два символа) на 'xz' в словах, длина которых равна 5
3) Поменять местами слово, начинающееся на 'a', со словом, оканчивающимся на 'z', при условии, что такие слова существуют и являются единственными
4) Удалить последние 3 символа из слов, начинающихся на 'a'
5) Удалить первые 3 символа из слов, оканчивающихся на 'th'
6) Дополнить символом '*' слова, имеющие длину меньше заданной (максимальной) до максимальной
7) Заменить первые 3 символа слов, имеющих выбранную длину, на символ '*'
8) Удалить все символы 'а' из слов, длина которых равна выбранной
9) Заменить все символы 'a' на 'd' в словах, длина которых меньше выбранной
10) Заменить первые строчные буквы на заглавные в каждом слове, длина которого больше выбранной
11) Вставить пробел после первых 2-х символов в слова, имеющие длину, на 1 меньше заданной
12) Заменить первую строчную букву на заглавную в словах, имеющих выбранную длину
13) Вставить пробел перед последними 2-мя символами в слова, имеющие минимальную (заданную) длину
14) Посчитать количество гласных букв в строке и заменить их на '*'
15) Упорядочить символы в строке по алфавиту
16) Вывести все слова, у которых первая и последняя буквы одинаковые
17) Упорядочить строку по убыванию длин слов
18) Проверить в математическом выражении, заданном строкой, соответствие открывающих и закрывающих скобок
19) Вывести все слова в строке в обратном порядке
20) Удалить двойные пробелы и переместить все найденные в тексте цифры в конец строки
1) Что такое строка?
2) Каким идентификатором определяются данные строкового типа?
3) Какова максимальная длина строки? Как определить длину строки?
4) Какие выражения называются строковыми?
5) Какие операции допустимы над строковыми данными?
6) Каким образом производится сравнение строк?
7) Как можно обратиться к отдельным символам строки?
8) Каково назначение специальных процедур и функций обработки данных строкового типа?
Приобретение навыков разработки Pascal-программы для работы с файлами с целью длительного хранения и загрузки необходимой информации.
Составить программу на языке Pascal, осуществляющую ведение информационного справочника в соответствии с вариантом задания (п. 7.7).
Программа должна выводить:
– номер варианта, назначение программы и ФИО автора;
– информационные сообщения о необходимости ввода данных;
– результаты работы в соответствии с вариантом задания.
Программа должна обеспечивать следующие операции (п. 7.6):
1) загрузка справочника из файла;
2) добавление новой записи;
3) вывод на экран списка всех записей;
4) поиск записи по заданному атрибуту;
5) сохранение справочника в файл.
1) Получить вариант задания (п. 7.7).
2) Изучить операторы объявления данных типа «запись» и операторы обработки типизированных и текстовых файлов (п. 7.5).
3) Разработать и отладить программу, осуществляющую ведение информационного справочника.
4) Ответить на контрольные вопросы (п. 7.9).
5) Оформить отчет (см. п. 1.11).
Помимо простых типов данных (Real, Integer, Byte, Char, Boolean и т.п.), а также массивов (array) и строк (string), в языке Pascal присутствует структурированный тип данных «запись», объявляемый с помощью ключевого слова RECORD. В ряде других языков программирования аналогичная языковая конструкция называется «структурой» (STRUCT). Формат объявления типа «запись»:
type
<наименование_типа> = record
<поле_1>: <тип_поля>;
<поле_2>: <тип_поля>;
<поле_N>: <тип_поля>;
end;
Таким образом, запись состоит из произвольного количества полей, каждое их которых может иметь любой известный компилятору тип (в том числе RECORD). Пример объявления типа RECORD и переменных:
type {Объявление типа}
TBirthDay = record
Fam: string[40]; {фамилия}
Day, Month: Byte; {день и месяц рождения}
Year: Word; {год рождения}
end;
var {Объявление переменых}
a, b: TBirthDay;
В этом примере тип TBirthDay (день рождения) представляет собой запись с полями Day, Month и Year (день, месяц и год), а также Fam (фамилия). Переменные a, b являются записями типа TBirthDay. Таким образом, в одной переменной объединено (инкапсулировано) сразу несколько разнотипных данных.
Между однотипными переменными-записями допускается операция присваивания, например: a := b.
Для доступа к полю записи (с целью его чтения или модификации) необходимо использовать составное имя, в котором имя поля отделяется от имени переменной символом «.» (точка), например:
a.Day := 1;
a.Month := 12;
a.Year := 2011;
a.Fam := 'Ivanov';
Следующий пример демонстрирует объявление массива, состоящего из элементов-записей, а также вывод содержимого массива на экран:
var
Mas: array[1..10] of TBirthDay;
....................
for I := 1 to 10 do
Writeln('Запись №', I, ': Фамилия=', Mas[I].Fam,
', Дата рожд=', Mas[I].Day, '.', Mas[I].Month, '.', Mas[I].Year);
Как видим, элементы массива, помимо простых типов и строк, могут быть также структурированными.
Приведенный пример является простым и очевидным, однако этого удалось достичь лишь за счет использования структурированных типов. Объединение (инкапсуляция) некоторого набора разнотипных данных в одной структуре – очень распространенный приём в программировании.
В независимости от используемого языка программирования (Pascal, C++, Java и т.д.), операционной системы (Windows, Linux, Unix, Mac-OS и т.д.), аппаратной архитектуры (персональный компьютер, сотовый телефон, промышленный контроллер и т.д.), рано или поздно перед программистом возникнет задача длительного хранения данных, необходимых для работы программы. В качестве энергонезависимого носителя, на который может быть сохранена информация для длительного хранения, могут выступать: дискета, кассетная лента, flash, fram, жесткий диск (магнитный или полупроводниковый) и т.д. В зависимости от используемой операционной системы, различаются способы организации информации на тех или иных носителях. Крайний и наиболее сложный случай заключается в том, что программист должен полностью продумывать механизмы хранения информации, вплоть до оперирования с памятью на уровне отдельных ячеек или кластеров. При использовании современных операционных систем (Windows, Linux и т.д.) вся сложность работы с тем или иным устройством прячется от программиста. В замен ему предлагается работать с более понятным и универсальным объектом – «файл». Файл – это именованный участок данных, сохраненных в энергонезависимой памяти (например, на флешке). Совершенно не важно, как физически хранятся данные (везде – по-разному). Программиста это вопрос не должен интересовать. Операционная система предоставляет программисту готовые функции для работы с файлами, осуществляющие: создание, открытие, закрытие файла, запись в файл, чтение из файла и ряд других функций.
После изучения (в достаточной мере) принципов работы с файлами, реализация (в будущей работе) иных способов хранения информации не должна представлять чрезмерных трудностей.
Хотя информация в файле всегда хранится в виде некоторого набора байтов, принято различать текстовые файлы (их можно открыть в простейшем текстовом редакторе, например «Блокнот», и внести необходимые изменения) и двоичные файлы (попытка открытия таких файлов в блокноте ничего полезного не даст). Как бы то ни было, перед началом работы с файлом необходимо объявить и инициализировать некоторую переменную (в терминологии языка Pascal – файловую переменную), после чего ее необходимо указывать в каждом операторе, выполняющем ту или иную работу с файлом.
Наиболее простой и понятной является работа с текстовыми файлами, поскольку пользователь в любой момент может открыть созданный файл из программы «Блокнот» и, при необходимости, внести в него свои изменения. В приведенном ниже примере программа в цикле требует от пользователя ввести строку, пока он не введет символ «*». Все вводимые строки будут сохраняться в указанный текстовый файл.
var
F: Text; {Объявление файловой переменной}
S: string[100];
begin
Assign(F, 'C:\TEMP\MyFile.txt'); {Инициализируем файловую переменную}
Rewrite(F); {Создаем текстовый файл с правом на запись}
repeat {основные действия выполняются в цикле}
Write('vvedite stroku> '); {вывод приглашения на экран}
Readln(S); {ожидаем, пока пользователь не введет строку}
Writeln(F, S); {запись введенной строки в файл}
until S = '*'; {если ввели "*", то выход из цикла}
Close(F); {Закрываем файл}
end.
После окончания работы с программой предлагается открыть полученный файл с помощью блокнота и убедиться в наличии всех введенных строк.
При работе с файлом необходимо в первую очередь инициализировать файловую переменную (в данном случае F: Text). Файловая переменная внутренне объявлена как RECORD с многочисленными полями, в том числе «имя файла» и «файловый указатель». Таким образом, данная структура является самодостаточной, что избавляет от необходимости многократного указания имени файла. Далее файл необходимо открыть. Существует несколько процедур открытия файлов (это связано с существованием большого количества режимов открытия), в результате успешной работы которых происходит открытие файла, после чего можно с ним работать, т.е. выполнять операции ввода/вывода. После завершения всех операций ввода/вывода файл необходимо закрыть. Если этого не сделать, то дальнейшие попытки открыть файл (например, в другой процедуре) могут окончиться неудачно.
Помимо текстовых файлов, язык Pascal существенно упрощает работу также и с двоичными файлами. Двоичный файл в общем случае нельзя открыть с помощью блокнота, однако, это более предпочтительный, универсальный и экономичный формат для хранения разного рода информации. Проще всего работать с «типизированными» двоичными файлами, поскольку в этом случае работа с файлом напоминает работу с одномерным массивом. Например, так выглядит код сохранения элементов массива в типизированный файл:
var
F: file of TBirthDay; {Объявляем файловую переменную}
I: Integer;
begin
Assign(F, 'MyFile.bin');{Инициализируем файловую переменную}
Rewrite(F); {Открываем файл для записи}
for I := 1 to ACount do {Цикл перебора записей}
Write(F, Mas[I]); {Сохраняем запись в файл}
Close(F); {Закрываем файл}
end;
Кроме того, Pascal позволяет работать с файлами, которые невозможно отнести ни к одному известному типу. В терминологии языка Pascal такие файлы являются «нетипизированными» (фактически – это массив байтов). На самом деле это наиболее привычный для большинства программистов способ представления, поскольку в таких файлах можно хранить совершенно любую информацию, как текстовую, так и двоичную. Разумеется, организация работы с нетипизированными файлами является несколько более сложной. Для ввода/вывода вместо процедур Read и Write используются процедуры BlockRead и BlockWrite. Более подробную информацию по работе с нетипизированными файлами в языке Pascal читатель может с легкостью получить в других источниках.
Процедуры по обработке текстовых и типизированных файлов, требуемые для выполнения данной лабораторной работы, приведены в таблице 7.1.
Таблица 7.1 – Процедуры для работы с файлами
|
Процедура |
Назначение |
|
Assign() |
Связывает имя файла с файловой переменной |
|
Append() |
Открывает текстовый файл для добавления новых записей в конец файла. Если файл не найден, то возникнет ошибка |
|
Reset() |
Открывает текстовый файл для чтения, или двоичный файл для чтения/записи. Если файл не найден, то возникнет ошибка |
|
Rewrite() |
Открывает текстовый или двоичный файл для записи. Файл будет создан и обнулен автоматически |
|
Write() |
Записывает заданное значение в файл |
|
Writeln() |
Записывает строку текста и символы перевода строки в текстовый файл |
|
Read() |
Считывает информацию из файла в заданную переменную |
|
Readln() |
Считывает строку из текстового файла |
|
Eof() |
Проверяет, не достигнут ли конец файла при чтении |
|
Erase() |
Уничтожает заданный файл |
|
Close() |
Выполняет закрытие файла |
В приведенном ниже примере реализована программа «Телефонный справочник», отвечающая требованиям к данной лабораторной работе (п. 7.3). Программа подробно прокомментирована, поэтому не нуждается в дополнительных пояснениях. Рекомендуется тщательным образом проанализировать предлагаемый пример, поскольку в нем найдутся ответы на многие вопросы, которые, несомненно, возникнут при выполнении работы.
program PhoneBook; {Программа "Телефонная книга"}
const
AFileName = 'phones.spr'; {Имя файла}
MaxRecordCount = 100; {Максимальное число записей в справочнике}
type
TFam = string[20]; {Объявление типа "фамилия абонента"}
{Описание записи из телефонной книги}
TPhoneRec = record
Fam: TFam; {фамилия абонента}
Phone: string[15]; {телефон абонента}
Pol: Boolean; {пол абонента TRUE-муж, FALSE-жен}
BirthYear: Word; {год рождения}
end;
{Объявление типа-массива записей телефонной книги}
TPhoneTable = array[1..MaxRecordCount] of TPhoneRec;
{Процедура выполняет загрузку справочника из файла}
procedure LoadFromFile(var ATable: TPhoneTable; var ACount: Integer);
var
F: file of TPhoneRec; {Объявляем файловую переменную}
begin
Assign(F, AFileName); {Инициализируем файловую переменную}
{$I-} {Отключаем генерацию ошибок ввода/вывода}
Reset(F); {Открываем файл для чтения}
{$I+} {Возвращаем директиву "I" в исходное состояние}
if IOResult = 0 then {Если файл успешно открыт}
begin {то считываем из него записи}
ACount := 0; {Обнуляем счетчик записей}
while not Eof(F) do {Пока не достигнут конец файла...}
begin
Inc(ACount); {Увеличиваем ACount на единицу }
Read(F, ATable[ACount]); {Считываем запись из файла}
end;
Close(F); {Закрываем файл}
Writeln('Spravochnik uspeshno zagruzhen iz faila: ', AFileName,
'. Kolichetvo zapisei: ', ACount);
end else {Иначе выводим сообщение "Файл не найден!"}
Writeln('ERROR: Fail ne naiden!');
end;
{Процедура выполняет сохранение справочника в файл}
procedure SaveToFile(const ATable: TPhoneTable; const ACount: Integer);
var
F: file of TPhoneRec; {Объявляем файловую переменую}
I: Integer;
begin
Assign(F, AFileName); {Инициализируем файловую переменную}
Rewrite(F); {Открываем файл для записи}
for I := 1 to ACount do {Цикл перебора записей}
Write(F, ATable[I]); {Сохраняем запись в файл}
Close(F); {Закрываем файл}
Writeln('Spravochnik uspeshno sohranen v fail: ', AFileName);
end;
{Процедура выводит на экран запись с указанным номером}
procedure ShowRecord(const ATable: TPhoneTable; Num: Integer);
var
ARec: TPhoneRec;
C: Char;
begin
ARec := ATable[Num];
if ARec.Pol then {if ARec.Pol = True}
C := 'm'
else
C := 'f';
Writeln('No', Num, ': Fam=', ARec.Fam, ', Tel=',
ARec.Phone, ', Pol=', C, ', God rozhd=', ARec.BirthYear);
end;
{Процедура выводит на экран список всех записей}
procedure ShowAllRecords(const ATable: TPhoneTable;
const ACount: Integer);
var
I: Integer;
begin
Writeln('Spisok vseh zapisei:');
for I := 1 to ACount do
ShowRecord(ATable, I);
end;
{Процедура добавления новой записи в справочник}
procedure AddNewRecord(var ATable: TPhoneTable; var ACount: Integer);
var
ARec: TPhoneRec;
C: Char;
begin
Write('Vvedite familiu: ');
Readln(ARec.Fam);
Write('Vvedite telefon: ');
Readln(ARec.Phone);
Write('Vvedite pol ("m" / "f"): ');
Readln(C);
if C = 'm' then
ARec.Pol := True {Мужчина}
else { if C = 'f' }
ARec.Pol := False; {Женщина}
Write('Vvedite god rozhdenia: ');
Readln(ARec.BirthYear);
Inc(ACount); {Увеличиваем счетчик записей на 1}
ATable[ACount] := ARec; {Записываем запись ARec в массив ATable}
Write('Dobablena zapis: ');
ShowRecord(ATable, ACount); {Печатаем запись на экран}
end;
{Процедура отыскивает запись по заданной фамилии и печатает на экране}
procedure FindRecord(const ATable: TPhoneTable; const ACount: Integer);
var
I: Integer;
IsFind: Boolean;
Fam: TFam;
begin
Write('Vvedite familiu: ');
Readln(Fam);
IsFind := False; {Сбрасываем флаг перед поиском}
for I := 1 to ACount do
if ATable[I].Fam = Fam then
begin
IsFind := True; {Устанавливаем флаг "Успешный поиск"}
Write('Zapis naidena: ');
ShowRecord(ATable, I);
Break; {Выход из цикла}
end;
if not IsFind then {Если запись не найдена}
Writeln('Zapis ne naidena!');
end;
var
MenuNum: Byte;
PhoneTable: TPhoneTable; {Переменная-справочник}
PhoneCount: Integer; {Текущее количество записей в справочнике}
begin
PhoneCount := 0; {При запуске программы справочник еще пуст}
Writeln('Telefonnaya kniga. Avtor: Ivanov I.I');
repeat
Writeln('Vvedite cifru dlya vypolneniya deistviya:');
Writeln('1 - zagruzka spravochnika iz faila');
Writeln('2 - novaya zapis');
Writeln('3 - spisok vseh zapisei');
Writeln('4 - poisk zapisi po familii');
Writeln('5 - sohranenie spravochnika v fail');
Writeln('6 - vyhod iz programmy');
Write('> ');
Readln(MenuNum);
case MenuNum of
1: LoadFromFile(PhoneTable, PhoneCount);
2: AddNewRecord(PhoneTable, PhoneCount);
3: ShowAllRecords(PhoneTable, PhoneCount);
4: FindRecord(PhoneTable, PhoneCount);
5: SaveToFile(PhoneTable, PhoneCount);
end;
until MenuNum = 6;
end.
Следует отметить, что благодаря разбивке программного кода на подпрограммы, основная часть программы оказалась очень простой. Несмотря на «солидный» размер (более 150 строк кода), разобраться в данном примере не составит чрезмерных трудностей (при условии последовательного выполнения всех предыдущих лабораторных работ).
|
№ |
Наименование справочника, поля |
Тип файла |
Поле поиска |
|
1 |
Контрагенты. Поля: наименование контрагента, ИНН, тип (True-юридическое, False-физическое лицо), год регистрации |
Текстовый |
Наименование контрагента |
|
2 |
Владельцы сотовых телефонов. Поля: ФИО владельца, модель телефона, идентификатор телефона (IMEI), дата приобретения |
Типизированный |
ФИО владельца |
|
3 |
Участники интернет-форума. Поля: ФИО участника, пол (True-мужской, False-женский), пароль, дата регистрации, |
Текстовый |
ФИО участника |
|
4 |
Улицы вашего города. Поля: название улицы, количество домов, протяженность (км), год основания |
Типизированный |
Название улицы |
|
5 |
Товарно-материальные ценности. Поля: наименование ТМЦ, штрих-код, количество на складе, стоимость |
Текстовый |
Наименование ТМЦ |
|
6 |
ГородаУкраины. Поля: наименование города, год основания, число жителей, площадь |
Типизированный |
Наименование города |
|
7 |
Учебная нагрузка группы. Поля: наименование предмета, количество часов, ФИО преподавателя, система оценки знаний (True-экзамен, False-зачет) |
Текстовый |
Наименование предмета |
|
8 |
Расписание занятий группы. Поля: день недели, тип недели (True-первая, False-вторая), наименование предмета, время начала |
Типизированный |
Наименование предмета |
|
9 |
Расписание назначенных встреч. Поля: ФИО, место встречи, дата и время встречи |
Текстовый |
ФИО |
|
10 |
Сотрудники. Поля: ФИО, должность, дата приема на работу, оклад |
Типизированный |
ФИО |
|
11 |
Поступления ТМЦ. Поля: наименование ТМЦ, наименование поставщика, количество, дата оприходования |
Текстовый |
Наименование ТМЦ |
1) Дать определение записи (record) в языке Pascal.
2) Дать определение понятия «файл». Какова общая особенность любых файлов?
3) Перечислить основные операции с файлами.
4) Дать определение понятия «текстовый файл». Каким образом в языке Pascal объявляется переменная текстового файла?
5) Дать определение понятия «двоичный файл».
6) Дать определение понятия «типизированный файл». Каким образом в языке Pascal объявляется переменная типизированного файла?
7) Перечислить операторы языка Pascal для работы с текстовыми файлами.
8) Перечислить операторы языка Pascal для работы с типизированными файлами.
1 Фаронов В.В. Turbo Pascal 7.0. Начальный курс. Учебное пособие. – М.: «Нолидж», 2001. – 576 с.
2 Лукин С.Н. Pascal 7.0. Самоучитель. – 1999. – 214 с.
3 Долинский М.С. Алгоритмизация и программирование на Turbo Pascal: от простых до олимпиадных задач: Учебное пособие. – СПб.: Питер, 2005. – 234 с.
4 Деревенец О.В. Песни о паскале. – 2011. – 590 с.
5 Фаронов В.В. Delphi 6. Учебный курс. – СПб.: Питер, 2002. – 512 с.
6 Сухарев М.В. Основы Delphi. Профессиональный подход. – СПб: Наука и техника, 2004. – 600 с.
7 Стив Тейксейра, Ксавье Пачеко. Delphi5. Руководство разработчика. – 2000. – 1816 с.
Міністерство освіти і науки України
Національний технічний університет України
“Київський політехнічний інститут”
(назва кафедри)
Лабораторна робота №__
з дисципліни „Мови програмування”
Виконав:
Студент групи
(шифр групи) (прізвище, ім’я, по батькові) (підпис)
Перевірив:
Викладач Оцінка
(вчені ступінь та звання, прізвище, ініціали) (підпис)
Київ – 2012