СОДЕРЖАНИЕ
1 Введение........................................................................................................ 5
1.1 Что такое "программирование"?........................................................... 5
1.2 Понятие алгоритма................................................................................. 5
1.3 Алгоритмический язык........................................................................... 7
2 Введение в язык Turbo Pascal....................................................................... 8
2.1 История создания языка......................................................................... 8
2.2 Алфавит языка........................................................................................ 8
2.3 Структура программы........................................................................... 9
3 Типы данных. Описание переменных........................................................ 11
3.1 Понятие типа данных. Система типов языка....................................... 11
3.2 Описание данных.................................................................................. 13
3.3 Целые типы........................................................................................... 13
3.4 Вещественные типы.............................................................................. 14
3.5 Арифметические выражения................................................................ 16
3.6 Символьный тип................................................................................... 16
3.7 Булевский тип........................................................................................ 17
3.8 Ограниченные типы.............................................................................. 19
3.9 Перечислимые типы.............................................................................. 20
4 Операторы................................................................................................... 21
4.1 Основные операторы............................................................................ 21
4.2 Составной оператор............................................................................. 23
4.3 Условный оператор.............................................................................. 23
4.4 Оператор варианта............................................................................... 25
4.5 Операторы циклов................................................................................ 25
4.6 Пустой оператор................................................................................... 28
5 Некоторые составные типы........................................................................ 29
5.1 Регулярные типы (массивы)................................................................. 29
5.2 Строковый тип...................................................................................... 30
5.3 Множественный тип.............................................................................. 32
5.4 Комбинированный тип (запись)........................................................... 35
6 Подпрограммы........................................................................................... 38
6.1 Назначение подпрограмм.................................................................... 38
6.2 Структура подпрограмм...................................................................... 38
6.3 Область действия имен......................................................................... 39
6.4 Механизм параметров.......................................................................... 40
7 Файловые типы........................................................................................... 46
7.1 Файлы. Файловые переменные............................................................ 46
7.2 Основные операции с файлами............................................................ 47
7.3 Примеры работы с файлами................................................................ 48
7.4 Текстовые файлы.................................................................................. 52
8 Модули. Графика........................................................................................ 54
8.1 Организация модулей........................................................................... 54
8.2 Модуль Graph....................................................................................... 55
8.3 Инициализация и выход из графического режима............................. 59
8.4 Вывод некоторых графических примитивов....................................... 60
8.5 Управление графическими элементами............................................... 60
8.6 Управление графическим курсором.................................................... 63
8.7 Вывод текстовой информации............................................................. 63
9 Ссылочные типы. Динамические переменные........................................... 64
9.1 Динамическая память. Статические и динамические переменные...... 64
9.2 Понятие ссылочных типов и указателей.............................................. 65
9.3 Списки................................................................................................... 66
10 Программа Turbo Pascal.......................................................................... 69
10.1 Основы работы с программой........................................................... 69
10.2 Отладчик............................................................................................. 74
Методические указания по выполнению контрольной работы №2............ 76
Литература..................................................................................................... 80
1 Введение
1.1 Что такое "программирование"?
Сейчас, наверное, практически невозможно найти человека, который бы не слышал таких слов, как "информатика", "программирование", а профессия программиста стала одной из самых многочисленных.
Чем же занимаются программисты? Наверное, самый простой ответ – создают программы для решения задач с помощью компьютера. Попробуем разобраться, из чего состоит процесс написания программы. Прежде всего, перед программистом ставится определенная задача. Очевидно, что для решения задачи недостаточно только знать язык, на котором требуется написать программу, самое главное – найти способ ее решения, алгоритм
. А сама программа
– это запись этого алгоритма на каком-либо языке, понятном машине. Процесс перевода на этот язык и называется программированием
, а язык, на который осуществляется перевод, называется алгоритмическим языком
. Именно поэтому самым важным в профессии программиста является умение создавать хорошие алгоритмы, а следовательно, и хорошие программы.
1.2 Понятие алгоритма
Понятие алгоритма
является одним из фундаментальных понятий информатики и широко используется в программировании – написание любой программы начинается с составления алгоритма. Алгоритмы возникли вместе с появлением математики и встречаются практически во всех областях человеческой деятельности. Например, в школьном курсе математики изучаются алгоритмы деления "столбиком", умножения дробей и т.д.; в курсе высшей математики – алгоритмы решения дифференциальных уравнений, нахождения интегралов и т.д. Кроме этого, можно описать алгоритмы выращивания цветов, сборки шкафа, проведения физического эксперимента и многие другие.
Определить это понятие можно следующим образом: алгоритм
– это конечный набор правил, однозначно задающих последовательность выполнения некоторых действий, направленных на достижение определенного результата. Однако, не любой набор правил можно назвать алгоритмом. Рассмотрим требования, которым должен удовлетворять алгоритм:
- универсальность
– алгоритм, как правило, решает не одну, а целый класс задач, которые различаются между собой параметрами, являющимися входными данными алгоритма; любой алгоритм применяется к входным
данным (их число может быть равным нулю) и имеет хотя бы один результат
(выходную величину);
- однозначность
– применение алгоритма к одним и тем же входным данным должно давать один и то же результат;
- конечность
– количество шагов алгоритма не может быть бесконечным.
Описать алгоритм можно разными способами. Например, алгоритм вычисления выражения 52
×(62
+32
), описанный словесным способом, будет выглядеть следующим образом: вычислить значения выражений 62
и 32
, сложить их и умножить полученную сумму на значение выражения 52
. Как правило, такие описания алгоритмов получаются громоздкими и неоднозначными, найти ошибки в них очень сложно.
Гораздо чаще для этих целей используются блок-схемы алгоритмов
. Они позволяют представить алгоритмы в более наглядном виде, это дает возможность анализировать их работу, искать ошибки в их реализации и т.д. В блок-схемах всегда есть начало
и конец
, между ними – последовательность шагов
алгоритма, соединенных дугами
. Шаги бывают безусловными
(изображаются прямоугольниками) и условными
(изображаются ромбами). Из ромба всегда выходят две стрелки – одна означает выполнение условия (обозначается обычно словом "да"), другая – невыполнение ("нет"). Вывод на экран значения выражения изображается параллелограммом. Например, опишем блок-схему алгоритма для нахождения максимального из трех заданных чисел a,b,c.
Рисунок 1.1 – Пример блок-схемы алгоритма
Если решение задачи сложное и достаточно длинное, то алгоритм может получиться громоздким и плохо обозримым. Избежать этого можно, заменив некоторые шаги алгоритма блоками, которые будут являться подалгоритмами. Блок обычно не элементарен, его размеры выбираются в зависимости от необходимости, однако, если он правильно составлен, то обладает всеми необходимыми признаками алгоритмического шага: имеет точку входа (четко выделенное начало) и может быть условным или безусловным. Разные блоки алгоритма связаны друг с другом только через точки входа и выхода, поэтому если блок верно решает свою задачу, то его внутренняя структура несущественна для остальной части алгоритма. Такое блочное представление особенно удобно на первых этапах решения сложных задач, когда детализация блоков производится позднее, и возможно, другими разработчиками.
1.3 Алгоритмический язык
Алгоритмы, описанные неформальными способами, как правило, сложны для понимания и неоднозначны. Для того чтобы исключить эти недостатки, используются алгоритмические языки.
Язык, используемый для формальной записи алгоритмов, называется алгоритмическим языком
.
При описании любого языка (в том числе естественного, например, русского, английского и т.д.) используются следующие понятия: алфавит
, синтаксис
и семантика
.
Алфавит
языка – это множество символов, которые могут быть использованы в текстах этого языка.
Синтаксис
– это набор правил, определяющих возможные сочетания (конструкции) из букв алфавита. Для описания синтаксиса языка, как правило, используют другой язык (метаязык) или синтаксические диаграммы.
Семантика
– это набор правил, определяющих значение (смысл) отдельных конструкций языка.
Одним из самых распространенных алгоритмических языков является язык Pascal, который полезен как для начинающих, так и для опытных программистов. Обучение программированию чаще всего основывается на этом языке.
2 Введение в язык Turbo Pascal
2.1 История создания языка
В 1968-1971 гг. в Цюрихском Институте информатики в Швейцарии Никлаусом Виртом был разработан язык программирования Pascal
. Необходимость создания подобного языка возникла за отсутствием инструмента обучения студентов "программированию как систематической дисциплине". Но достаточно скоро стало ясно, что этот язык очень эффективен как для решения разных задач, так и для разработки сложных систем. И при этом он прост и легок в изучении.
Pascal – процедурный язык, имеющий блочную структуру. Набор операторов языка отражает принципы структурного программирования.
Язык Turbo Pascal, созданный фирмой Borland International, является реализацией языка Pascal для персональных компьютеров. Turbo Pascal – это язык профессионального программирования, одна из особенностей которого состоит в наличии интегрированной среды, включающей ряд мощных программных средств подготовки, редактирования, компиляции и отладки программного обеспечения. К достоинствам Турбо-Паскаля можно отнести:
- простоту и естественность основных конструкций языка, что позволяет быстро его освоить и создавать алгоритмически сложные программы;
- возможность использования развитых средств представления структур данных, что обеспечивает удобство работы как с числовой, так и с символьной информацией;
- соответствие языка структурному программированию, что делает программы наглядными и упрощает их разработку и отладку;
- наличие обширной библиотеки процедур и функций для работы как с текстовой, так и с графической информацией, что позволяет создавать достаточно сложные коммерческие программы с развитым удобным интерфейсом пользователя.
2.2 Алфавит языка
Алфавит языка включает следующие символы:
Заглавные и строчные латинские буквы и символ "_" (который тоже считается буквой). Используются при создании идентификаторов
и служебных слов
.
- Цифры от 0 до 9. Используются при записи чисел и идентификаторов.
- Специальные символы: + - * / = > < . , ; : @ ^ ‘ ( ) [ ] { } $ #
используются как знаки операций
, синтаксические разделители
, при записи выражений, комментариев.
Символы алфавита языка используются для построения лексем
– элементарных единиц языка, имеющих самостоятельный смысл. К лексемам относятся служебные слова, идентификаторы, знаки операций, разделители, изображения.
Служебные слова
– это конечный набор зарезервированных слов, смысл которых определен в языке. Служебные слова нельзя использовать в качестве идентификаторов. Примеры служебных слов: begin, end, const, var, if, then и т.д.
Идентификаторы
– это имена переменных, констант, процедур, функций, типов, меток. Составляются из букв, цифр и знаков подчеркивания в соответствии со следующими правилами:
- длина идентификатора может быть произвольной, однако компилятор воспринимает только первые 63 символа;
- первым символом обязательно должна быть буква или знак подчеркивания.
В Pascal строчные и заглавные буквы в идентификаторах и служебных словах не различаются, поэтому следующие идентификаторы считаются одинаковыми:
My_Function;
my_function;
MY
_
FUNCTION
.
Знаки операций
формируются из одного или нескольких специальных символов, например: <=, <>, >.
Разделители
также формируются из одного или нескольких спецсимволов и предназначены для наглядности программ.
В текстах программ возможно наличие пояснений, которые называются комментариями
и не меняют смысл программы. Комментарий может находиться между любыми двумя лексемами программы, представляет из себя любую последовательность символов (т.е. может включать буквы русского алфавита), заключенную в фигурные скобки:
{Данная строка является комментарием}.
2.3 Структура программы
Так как Pascal – алгоритмический язык, программа, написанная на этом языке, является записью некоторого алгоритма, т.е. последовательности действий.
В целом программа на языке Pascal состоит из двух основных частей: описание всех данных, с которыми производятся действия, и описание самих действий. Кроме этого, в самом начале программы может присутствовать ее название – заголовок, который рассматривается как комментарий. В самом конце программы ставится точка ".
".
В разделе описания могут быть следующие объекты:
- переменные;
- константы;
- типы;
- метки;
- подпрограммы.
Общая структура программы примерно выглядит следующим образом:
Program
<имя программы>; {заголовок программы}
Label
{раздел описания меток}
Const
{раздел описания констант}
Type
{раздел описания типов}
Var
{раздел описания переменных}
Begin
{тело программы, представляет из себя последовательность операторов, разделенных символом ";
"}
End.
Обратите внимание, что имя программы заключено в треугольные скобки, такие скобки используются только для того, чтобы показать, что их содержимое может изменяться. При написании программы треугольные скобки не ставятся. Например, можно использовать различные заголовки программы: Program Hello или Program My_prog.
3 Типы данных. Описание переменных
3.1 Понятие типа данных. Система типов языка
Теоретически научиться программировать невозможно. Поэтому все, что вы будете изучать с помощью данного пособия, желательно реализовывать практически. Вы должны писать программы, начиная с простых и все более усложняя их. Если у вас возникают проблемы с компиляцией, отладкой, то в этом случае сначала обратитесь к главе 10, в которой изложены основы работы с программой-компилятором Turbo Pascal.
В любой задаче используются, обрабатываются какие-либо данные – числа, целые или вещественные, массивы, символы, слова и т.д. Все они характеризуются своим типом
. Классификация различных данных по типам возникла по следующим причинам. Во-первых, тип фактически характеризует множество значений к которым относится константа, которые может принимать некоторая переменная или выражение и которые может формировать функция. Во-вторых, благодаря указанию типа определяется множество операций, которые можно применять к данным этого типа. Например, числа можно перемножать и делить, но операции умножения и деления недопустимы для строк. В-третьих, указание типа данных необходимо для правильного представления данных в памяти машины.
Рисунок 3.1 – Система типов языка Pascal
Pascal является типизированным языком. Это означает, что тип переменной задается при ее описании и не может быть изменен. Это, на первый взгляд, неудобство заставляет программиста быть аккуратным и внимательным, обеспечивает большую легкость при поиске ошибок и высокую надежность программ.
Система типов языка Pascal состоит из набора стандартных типов
, т.е. таких, для которых множества допустимых значений и операций над ними уже определены. На основе этих типов программист может создавать собственные типы произвольной структуры и сложности.
В языке Pascal базовыми являются простые
типы. Составные
типы строятся из простых в соответствии с определенными правилами. Ограниченные
типы создаются из простых путем сужения их области допустимых значений. Ссылочные
типы образуются из любых других. Процедурные
типы расширяют традиционное понятие подпрограмм, позволяя обращаться с ними как с переменными.
Первичными в иерархии типов являются стандартные скалярные, представляющие традиционные типы в языках программирования множества значений (целые, вещественные, символьный и булевский). Это предопределенные типы, зафиксированные в языке.
Рисунок 3.2 – Стандартные скалярные типы языка Pascal
Существует два способа создания новых типов на основе стандартных скалярных – ограниченные
и перечислимые
типы.
Любой скалярный тип характеризуется множеством его различных значений, среди которых установлен линейный порядок. Все скалярные типы, кроме вещественных, называются дискретными
.
3.2 Описание данных
Основная единица данных во всех языках – это переменная
. Она определяется именем (идентификатором) и значением. Каждая переменная, используемая в программе, должна иметь свой тип, который указывается в разделе описания переменных. Причем описание переменной, за исключением системной (предописанной)
, обязательно должно быть произведено до первого ее использования.
Раздел описания переменных начинается со служебного слова
var, само описание переменной содержит два элемента: имя переменной (идентификатор) и ее тип. Эти элементы разделяются двоеточием, после указания типа ставится разделитель – символ ";".
Var <имя переменной>:<тип переменной>;
Так как Pascal статический язык, то это описание остается неизменным во всей области определения переменной. Если несколько переменных имеют один тип, их описания объединяются в одно, при этом имена указываются через запятую.
Var <имя переменной1>,<имя переменной2>:<тип переменных>;
3.3 Целые типы
Для работы с данными представленными целыми числами используются целые типы. Это 5 типов (Integer
,
Byte
,
Shortint
,
Word
,
Longint
), обозначающих множества целых чисел в различных
диапазонах. Типы различаются допустимым диапазоном значений и размером занимаемой оперативной памяти. Характеристики типов приведены в следующей таблице:
Таблица 3.1 – Целые типы
| Название типа |
Диапазон допустимых значений |
Размер памяти |
| Shortint
|
-128..127 |
1 байт |
| Integer
|
-32768..32767 |
2 байта |
| Longint
|
-2147483648..2147483647 |
4 байта |
| Byte
|
0..255 |
1 байт |
| Word
|
0..65535 |
2 байта |
Таким образом, если переменные принимают только положительные значения по смыслу задачи, их следует описать с помощью типов Byte или Word. Если предполагается работа с большими числами, то переменные следует описать с помощью типа Longint. Приведем пример описания переменных.
Var a1:integer;
b,c:byte;
x,y,z:longint;
При таком описании в памяти выделится два байта под переменную а1, по одному байту для переменных b и c, и по четыре байта для переменных x, y и z.
3.4 Вещественные типы
Для работы с дробными (вещественными числами) используются вещественные типы. Это 5 типов (Real,
Single,
Double,
Extended,
Comp
), обозначающих множества вещественных чисел в различных диапазонах.
Вещественные значения в программе могут изображаться двумя способами:
- в форме с фиксированной точкой, когда целая часть от дробной отделяется с помощью точки (4.786, 1.0, -65.23 и т.д.);
- в форме с плавающей точкой (запись числа состоит из двух элементов – мантиссы и порядка, между ними ставится символ "Е". Например, запись числа 2,8*109
выглядит, как 2.8Е9, число 0,000001 равно 0,1*10-5
и записывается как 0.1Е-5).
Примеры неправильных форм записи:
.987
-12. в записи должны обязательно присутствовать и целая, и 4,067 дробная части, отделяемые друг от друга с помощью точки.
Вещественные типы отличаются друг от друга допустимым диапазоном значений и размером занимаемой оперативной памяти. Характеристики типов приведены в следующей таблице:
Таблица 3.2 – Вещественные типы
| Название типа |
Диапазон допустимых значений |
Размер памяти |
| Real
|
2.9е-39 .. 1.7е38 |
6 байт |
| Single
|
1.5е-45 .. 3.4е38 |
4 байта |
| Double
|
5.0е-324 .. 1.7е308 |
8 байт |
| Extended
|
3.4е-4932 .. 1.1е4932 |
10 байт |
| Comp
|
-2е+63 .. +2е+63-1 |
8 байт |
Операции, допустимые над целыми и вещественными значениями
Арифметические операции
(+ , - , * , /
) применимы, как к целым так и к вещественным значениям. Из таблицы можно увидеть, какого типа результат будет получен при выполнении этих операций над данными целого или вещественного типа.
Таблица 3.3 – арифметические операции
| a
|
b
|
a+b
|
a-b
|
a*b
|
a/b
|
| целое |
целое |
целое |
целое |
целое |
вещественное |
| целое |
вещественное |
вещественное |
вещественное |
вещественное |
вещественное |
| вещественное |
целое |
вещественное |
вещественное |
вещественное |
вещественное |
| вещественное |
вещественное |
вещественное |
вещественное |
вещественное |
вещественное |
Операции отношения
(=, <>, >=, <=, >, <). Целые числа можно сравнивать, как с целыми так и с вещественными.
Для целых типов определены еще две операции:
- операция "деление нацело" с отбрасыванием дробной части, обозначается служебным словом div
(14 div 3 =4, 5 div 8=0);
- операция "взятие остатка от целочисленного деления", обозначается служебным словом mod
(14 mod 3 =2, 5 mod 8=5).
Кроме описанных выше операций в языке Паскаль существует ряд стандартных функций применимых к числовым данным. Опишем некоторые из них.
trunc
(
x
)
– отбрасывание вещественной части x
, x
– вещественное значение (trunc(5.67)=5.
round
(
x
) –
операция округления вещественного числа х
до ближайшего целого (round(5.67)=6; round(5.47)=5).
sqr
(
x
)
–
функция возведения в квадрат, где x
переменная целого или вещественного типа, значение функции совпадает с типом аргумента.
sqrt
(
x
)
– функция извлечения квадратного корня, где x
переменная целого или вещественного типа, значение функции всегда вещественного типа.
Sin
(
x
),
cos
(
x
),
arctan
(
x
)
–
тригонометрические функции, аргументы и значения которых всегда вещественного типа, причем для sin(x), cos(x) значение переменной х задается в радианах.
Abs
(
x
)
–
функция определения модуля числа х, где x
переменная целого или вещественного типа, значение функции совпадает с типом аргумента.
Exp
(
x
)
– экспонента в степени х,
где аргумент целого или вещественного типа, значение функции всегда вещественного типа.
Ln
(
x
)
–
натуральный логарифм х, где аргумент целого или вещественного типа, значение функции всегда вещественного типа.
Функции Ln
(
x
)
и Exp
(
x
)
могут быть
использованы для возведения в степень по правилу: хn
=enln
(
x
)
. Например, значение х9
вычисляется по формуле exp(9*ln(x)).
3.5 Арифметические выражения
Константы
по внешнему виду похожи на переменные, однако, в отличие от них, не могут изменить своего значения. Описание констант начинается со служебного слова const
. Описание каждой константы включает всегда только два элемента: идентификатор и константное выражение, разделенные символом "=", заканчивается символом ";". Пример:
const
max = 1000;
Pi = 3.1415;
С = Pi*2;
min = -max;.
Тип константы в описании не указывается, он определяется автоматически по ее значению. Значение константы в теле программы изменить нельзя.
Переменные и константы – это частные случаи выражений
. В общем случае можно сказать, что выражения строятся из операндов
, знаков операций
и круглых скобок.
Выражения используются для вычисления новых значений, т.е. имеют тип, который определяется синтаксически в зависимости от типов операций и операндов.
Операнды
– это некоторые "элементарные" значения: переменные, константы, вызовы функций.
При составлении выражений необходимо знать следующие правила.
1. Все выражение должно быть записано в строку. Двухэтажные выражения, а так же верхние и нижние индексы не допускаются. Например: ((а1*х1)-(а2*х2))/(х1-х2).
2. В выражении в качестве разделителей можно использовать только круглые скобки.
3. Нельзя записывать подряд два знака. Например, форма записи а+в/-с
неправильна, правильной является форма а+в/(-с)
.
Примеры выражений:
a+b*x;
y-(2*y+c)*y;
sin(x)*2+56.
3.6 Символьный тип
Переменные этого типа описываются служебным словом char
.
Язык Pascal позволяет работать не только с численными данными, но и с символьными. Значениями символьного типа являются символы из множества ASCII (American Standart Code For Information Interchange - американский стандартный код для обмена информацией).
Это множество включает 256 различных символов, расположенных в определенном порядке и пронумерованных. Номера символов – целые числа в диапазоне 0..255. Допускаются некоторые отклонения от стандарта ASCII, в частности при наличии соответствующей системной поддержки это множество может содержать буквы русского алфавита. Размер памяти, занимаемый символом, 1 байт.
Если символьное значение имеет графическое представление, то оно изображается соответствующим знаком, заключенным в одинарные кавычки (апострофы), например: '
R
'
'+' '-' 's'. Для представления самого апострофа его изображение удваивается: ''''.
Если символ, который нужно изобразить, не имеет графического представления, то можно воспользоваться следующей эквивалентной формой записи, состоящей из символа ‘#’ (решетка, диез) и целочисленного кода символа (от 0 до 255): #10, #13.
Операции, возможные над символьными данными:
- операции сравнения – результат операции определяется сопоставлением кодов сравниваемых символов, тот символ больше, чей код больше;
- функция ord
(
c
)
(с
– переменная символьного типа) вычисляет порядковый номер символа с
(например, ord
('
R
')=82
);
- функция chr
(
i
)
(i
– переменная целого типа) выдает символ с
порядковым номером i (например, chr
(68)='
D
'
);
- функция pred
(
c
)
выдает предыдущий по отношению к с
символ (например, pred
('9')='8'
);
- функция succ
(
c
)
выдает следующий после символа с
символ (например, succ
('
b
')='
a
'
).
3.7 Булевский тип
Логический тип данных часто называют Булевским типом, по имени английского математика Джорджа Буля, создателя особой области математики – логики. Основу математической логики составляют две константы: True (Истина, 1) и False (Ложь, 0). Логические данные широко используются при сравнении величин. Результат сравнения может быть истинным или ложным.
Примеры.
1) a2
=b2
+c2
– истинно при a=5, b=4, c=3
ложно при a=2, b=3,c=4.
2) x2
<0 – всегда ложно.
В языке Паскаль переменные логического типа могут принимать значения True и False. Значения этого типа занимают 1 байт памяти. Описание переменных логического типа выполняется с помощью служебного слова Boolean.
Var
A, B: Boolean;
В теле программы такой переменной можно присваивать значения логических констант True и False.
Пример.
A:=True;
B:=False;
Логические выражения
Как уже отмечалось выше, логические данные широко используются при сравнении величин. В результате сравнении величин, получается либо ложное, либо истинное значение. В языке Pascal для сравнения данных предусмотрены следующие операции отношения (сравнения):
< - меньше;
> - больше;
= - равно;
<= - меньше или равно;
>= - больше или равно;
<> - не равно.
Отношения можно использовать в правой части оператора присваивания. Например:
A:=3<6; {Всегда False}
A:=x1<>x2;
B:=(x1+x2)<18;
В математической логике имеются специальные логические операции:
Or – логическое сложение (ИЛИ),
And –логическое умножение (И),
Not – логическое отрицание (НЕ).
Логическое сложение дает ложный результат только в том случае, когда оба операнда ложные.
Логическое умножение дает истинный результат только в том случае, когда оба операнда истинны.
Операция отрицания дает ложный результат, если операнд истинный, и, наоборот, истинный результат, если операнд ложный.
Данные о результатах логических операций представлены в таблице 3.4.
Таблица 3.4 – логические операции
| A |
B |
A or B |
A and B |
Not A |
| False |
False |
False |
False |
True |
| False |
True |
True |
False |
True |
| True |
False |
True |
False |
False |
| True |
True |
True |
True |
False |
Примеры.
(A<3)Or(B>2) – при A=4, B=0 – ложно, при A=4, B=3 – истина.
(A<3)And(B>2) – при A=1, B=10 –истина, при A=3, B=3 – ложь.
Not (A<2) – при A=1 – ложь, A=4 – истина.
Таким образом, логические выражения строятся из логических переменных, логических констант, логических операций, операций отношений.
Кроме того, в языке существует система приоритетов
, т.е. очередности выполнения операций в выражении. Для изменения очередности предназначены круглые скобки – часть выражения, заключенная в скобки рассматривается как отдельный операнд.
Приоритет операций (от высшего к низшему):
1) not;
2) *, / , and,div, mod;
3) +, -, or;
4) =, <>, <,>, <=, >= .
3.
8 Ограниченные типы
Это самый простой способ образования нового типа из уже существующего путем ограничения его области допустимых значений. Для этого надо задать максимальное и минимальное значения:
Var
х: -1000..1000;
с: ‘
a
’..’
z
’;
y
: 0..9.
В качестве базового типа допускается использовать любой дискретный тип, причем новый тип наследует все свойства базового.
Описанному таким образом типу можно задать идентификатор, который можно использовать при описании переменных и создании новых типов.
Использование ограниченных типов существенно улучшает наглядность программы и, кроме того, позволяет эффективно контролировать выходы значений за пределы заданного диапазона.
3.9 Перечислимые типы
Другой способ создания нового типа – перечисление всех возможных его значений, причем каждое такое значение будет определяться именем. Описание этого типа представляет собой набор значений, заключенный в скобки, сами названия значений разделяются запятой. При создании любых новых типов их необходимо описать в разделе описания типов, который начинается со служебного слова type и располагается в соответствии с общей структурой программы. Например:
type
color = ( red, yellow, green );
direction = ( left, right, up, down );
Var
c: color;
d: direction;
Перечислимые типы считаются дискретными. Названия значений в пределах одного блока должны быть уникальны.
4 Операторы
Поскольку язык Pascal алгоритмический, то для записи шагов алгоритмов, для наглядного однозначного представления алгоритмов в стиле структурного программирования существует набор операторов. Основные операторы считаются простыми, остальные – структурными, т.е. в их состав могут входить другие операторы, причем глубина "вложенности" операторов не ограничена.
4.1 Основные операторы
Оператор присваивания
Предназначен для присваивания переменной значения выражения. Оператор обозначается символом ":=", в левой части указывается имя переменной, в правой – вычисляемое выражение. Оператор считается синтаксически правильным, если тип выражения в правой части совпадает с типом переменной. Допускается использование этого оператора с переменными любого типа, кроме файлового.
Примеры использования оператора присваивания:
с переменными целого типа: x:=200;
вещественного: y
:=
Sin
(
Pi
/3);
символьного: c
:=‘6’;
булевского: test:=false;
Операторы ввода и вывода
Для того чтобы программа могла работать в диалоговом режиме (позволяла бы вводить данные и видеть результаты работы на экране) существуют операторы ввода и вывода. Существует две формы оператора ввода: read
и readln
.
read(x1,x2,x3…);
Оператор read
обеспечивает ввод данных разных типов с клавиатуры. В скобках указываются имена переменных, которым присвоятся введенные значения. При вводе нескольких значений с помощью одного оператора они разделяются символом "пробел". Для окончания ввода (завершения работы одного оператора read) нажимается клавиша "Enter". Если же в программе есть несколько подряд идущих операторов read, то данные вводятся потоком
, т.е. без нажатия "Enter".
readln(x1,x2,x3…);
Оператор readln
аналогичен предыдущему, отличие заключается в том, что при выполнении одного оператора readln
курсор на экране монитора переходит на новую строку.
Примеры:
read(a);
read(a,b,c);
readln(x,y).
Аналогично существует две формы оператора вывода:
write(x1,x2,x3…);
В результате выполнения данного оператора значения переменных x1,x2,x3… будут выведены на экран монитора. Если необходимо вывести на экран какой-либо текст, то внутри оператора write
этот текст записывается в апострофах:
x:=5;
write(‘x=‘,x);
Результат выполнения этих операторов:
x=5.
writeln(x1,x2,x3…);
Аналогичен оператору write
, отличие заключается в том, что после выполнения оператора writeln
курсор переходит на одну строку вниз. Оператор writeln
может использоваться без каких-либо параметров – в этом случае после выполнения такого оператора курсор просто перемещается на одну позицию вниз, так, например, выполнение последовательности команд
writeln;
writeln;
writeln;
writeln;
writeln;
приведет к тому, что курсор опустится на пять строк вниз.
Примеры:
writeln(‘Hellow World!’);
write(‘a=‘,a,’ b=‘,b,’ c=‘,c);
Операторы вывода обеспечивают вывод на экран не только значений переменных, но также и значения выражений. Например, в результате выполнения следующих операторов:
x:=4;
y:=3;
writeln(‘Значение выражения = ‘, x + sqr( y ));
получим на экране монитора следующее сообщение:
Значение выражения = 13.
В операторах вывода write
и writeln
имеется возможность установить ширину поля вывода.
Если x
и i
- целочисленные выражения, а y
- вещественное выражение, то вызов
write(x : i, y : i
)
печатает значения x
и y
каждое в крайние правые позиции полей шириной i
;
write(y : i : x)
вызовом в крайние правые позиции поля шириной i
символов выводится десятичное представление значения y
в формате с фиксированной точкой, причем после десятичной точки выводится x
цифр, представляющих дробную часть числа.
4.2 Составной оператор
Для того чтобы задать последовательное выполнение (по порядку, один за другим) нескольких операторов, в языке Pascal существует составной оператор
. Операторы, входящие в составной, разделяются символом ";
", в начале ставится служебное слово begin
, в конце – end
.
Составной оператор применяется в тех случаях, когда синтаксис языка допускает использование только одного оператора, а смысл требует выполнения нескольких действий. Пример составного оператора:
| begin x:=10; writeln(‘y=‘,x*sqr(x)) end |
Обратите внимание: перед служебным словом end
разделитель (символ ";
") не ставится
.
4.3 Условный оператор
Очень часто так же, как и в жизни, при решении задач некоторые действия выполняются в зависимости от истинности каких-либо условий. Например, мы берем с собой зонт, если идет дождь или на небе тучи. Или часто встречающиеся в математике определения функций:
если x<0, то f(x)=x+1;
если x>=0, то f(x)=2x.
Здесь значение функции f
вычисляется в зависимости от величины x по разным формулам.
Для задания выбора того или иного действия в зависимости от условия в языке Pascal предназначен условный
оператор
, который имеет две формы: полную и сокращенную.
Полная форма:
if
<условие>
then
<оператор1>
else
<оператор2>;
В качестве условия используется значение логического выражения, в качестве операторов – любой простой или составной оператор, в том числе и сам условный оператор.
Если значение логического выражения – true
, то выполняется оператор1, если false
, то выполняется оператор2.
Часть условного оператора, начинающаяся со слова else
,
может отсутствовать, такая форма оператора называется сокращенной
и выглядит следующим образом:
if
<условие>
then
<оператор>;
Оператор в этом случае выполняется, если условие истинно, иначе программа переходит к следующему оператору.
Для примера полной формы рассмотрим определение функции f(x):
if x<0 then f:=x+1
else f:=2*x;
Если в нашем примере описать логическую переменную В, значение которой будет равно true
, если x<0, и false
иначе, то можно записать так:
B:=x<0;
If B then f:=x+1
else f:=2*x;
Пример краткой формы:
if not((x<3) and (x>1)) then y:=sqr(x);
При использовании вложенных условных операторов может возникнуть неоднозначность, например:
if
<условие1>
then
if
<условие2>
then
<оператор1>
else
<оператор2>.
В данном случае необходимо помнить, что служебное слово else
всегда ассоциируется с ближайшим по тексту программы словом if
, которое еще не связано с else
. А чтобы такая двусмысленность не возникала, лучше всего пользоваться составным оператором:
if
<условие1> then
begin
if <условие2> then
<оператор1>
else
<оператор2>
end
;
4.4 Оператор варианта
Более обобщенной формой условного оператора, учитывающей произвольное число альтернатив, является оператор варианта
. Использование этого оператора позволяет задавать выполнение некоторых действий для нескольких различных значений одного выражения:
case
<выражение> of
<значение1
> :
<оператор1
>;
<значение2
> :
<оператор2
>;
<значение3
> :
<оператор3
>;
… …
else
<операторN
>
end
<операторN
> выполнится только в том случае, если значение выражения не совпадет ни с одним из <значенийi
>. В качестве <значения> можно также задать список и(или) диапазон значений. Например:
case x of
1..2 : f:=5;
3, 4, 10..20 : f:=10;
5, 6 : f:=15;
else writeln(‘Введен неправильный параметр!’)
end
4.5 Операторы циклов
Очень часто возникает необходимость выполнить один и тот же оператор (или группу операторов) несколько раз. Для этого в языке Pascal предусмотрены операторы циклов.
Оператор цикла с предусловием
.
Блок схема такого оператора:
Форма записи:
while
<условие> do
<оператор>;
В качестве оператора может быть любой простой или составной оператор. Оператор
здесь выполняется только в том случае и до тех пор, пока истинно условие
, которое проверяется каждый раз после выполнения оператора. Если с самого начала условие имеет значение false
, оператор цикла не выполнится ни разу.
Примеры:
Вычисление факториала:
while x <=N do
begin {начало цикла}
Fact := Fact*x;
x := x + 1
end; {конец цикла}
Вычислить у=х2
при х=2, 4, 6, 8, 10:
x:=2;
while x<=10 do
begin {начало цикла}
y:=sqr(x);
writeln(‘x=‘,x:3, ‘y=‘,y:5);
x:=x+2
end; {конец цикла}
Если в операторе цикла условие всегда истинно, то такой цикл называется бесконечным
:
t:=true;
while t do x:=x+5;
Оператор цикла с постусловием
Блок-схема оператора:
Форма записи:
repeat
<оператор1
>;
<оператор2
>;
…
until <условие>;
Последовательность операторов может состоять из одного или нескольких любых операторов. В отличие от предыдущего, в этом цикле условие проверяется всегда после выполнения оператора (или последовательности операторов), если оно ложно – оператор снова выполняется, иначе цикл прекращается. При такой структуре оператор хотя бы один раз обязательно выполнится.
Примеры:
Вычислить у=х2
при х=2, 4, 6, 8, 10.
x:=2;
repeat {начало цикла}
y:=sqr(x);
writeln(x:3,y:5);
x:=x+2
until x>10; {конец цикла}
Вводить символы с клавиатуры до тех пор, пока не будет введен символ "!"
Repeat {начало цикла}
writeln(‘введите символ’);
readln(c)
until c=‘!’; {конец цикла}
Оператор цикла с параметром
Этот оператор используют, когда количество повторений цикла известно заранее или необходимо изменять какую-либо величину на одно и то же значение в определенном диапазоне. Форма записи оператора:
for <параметр> := <начальное значение>
to <конечное значение>
do <оператор>;
Служебное слово to
указывает направление изменения параметра – увеличение на 1 (начальное значение меньше конечного значения; если это условие не выполнится, оператор в теле цикла не выполнится ни разу). Если необходимо, чтобы параметр уменьшался на 1, то используют слово downto
(начальное значение больше конечного значения). В качестве оператора можно использовать любой простой или составной оператор.
При использовании этого оператора цикла нужно помнить следующие правила:
1) в качестве параметра можно использовать простую переменную, описанную в этом же блоке;
2) параметр должен иметь дискретный тип;
3) начальное и конечное значения должны иметь тот же тип, что и параметр;
4) в теле цикла (операторе) явное изменение значения параметра (например, оператором присваивания) может привести к бесконечному циклу;
5) нельзя в теле цикла изменить начальное и конечное значения параметра, если они заданы переменными.
6) после завершения работы цикла значение параметра становится равным конечному значению параметра, если цикл не был прерван оператором перехода.
Для каждого значения параметра между начальным и конечным оператор в теле цикла выполняется только один раз.
Примеры:
Вывести на экран все символы от ‘a’ до ‘z’:
for i := ‘a’ to ‘z’ do write(i, ‘ ‘);
Вычислить у=х2
при х=2, 4, 6, 8, 10.
x:=2;
for i:=1 to 5 do
begin
y:=x*x;
writeln(x:3,y);
x:=x+2
end;
4.6 Пустой оператор
В языке Pascal есть такое понятие, как "пустой оператор" – оператор, который не имеет графического представления и не производит никаких действий. Причин существования такой конструкции несколько. Например, символ ";" синтаксически является разделителем, т.е. оператор, после которого идет служебное слово end
, не должен заканчиваться этим символом:
begin
s1; s2; s3
end;
Но если предположить, что после оператора s3 идет пустой оператор, тогда такая форма записи тоже правильна:
begin
s1; s2; s3;
end;
Другой пример использования пустого оператора – бесконечный цикл, не выполняющий никаких действий и завершающийся после нажатия любой клавиши:
repeat until keypressed;
Здесь подразумевается, что между словами repeat
и until
находится пустой оператор.
5 Некоторые составные типы
Переменные простых типов имеют атомарные (неразделимые) значения. В отличие от них, переменные составных типов имеют "сложные" значения, т.е. представляют собой совокупность нескольких значений другого типа. Таким образом, можно сказать, что составные типы – это еще один способ образования новых типов.
5.1 Регулярные типы (массивы)
Массивы – наиболее часто используемые типы данных. Каждое значение массива – это некоторое фиксированное количество значений одного и того же базового типа. Другими словами, такой тип данных позволяет объединять несколько значений одного типа в группу, причем имя дается всей группе в целом, а не каждому значению, сами же значения просто нумеруются. Доступ к элементам группы осуществляется по их номерам (индексам).
Массивы характеризуются типом элементов, их количеством и "способом нумерации". Определение массива в программе имеет вид:
type
<имя типа> =
array
[тип индекса]
of
<тип элементов>;
Тип индекса – любой дискретный тип, кроме longint
.
Поскольку индексов у элементов массива может быть несколько (например, в математике, элементы матриц имеют два индекса), то в описании можно указать не один тип индекса, а несколько, разделенных символом ",
". Примеры описания массивов:
type
letters = array [1..40] of char;
matrix1 = array [1..10] of array [1..5] of integer;
matrix2 = array [1..10,1..5] of real;
var
alf : letters;
A, С : matrix1;
B : matrix2;
Возможно непосредственное описание массивов в разделе описания переменных:
Var
аlf: array [1..40] of char;
А: array [1..10] of array [1..5] of integer;
Тогда обращение к элементам массивов будет выглядеть следующим образом:
alf[1]:=‘a’;
B[1,1]:=14.9;
Элементы массива считаются переменными и могут участвовать в любых операциях, допустимых с элементами данного типа. Над всем массивом в целом возможна операция присваивания, когда типы выражений в обеих частях совпадают:
А := С;
Примеры использования массивов
1. Пусть имеется массив A
, состоящий из n элементов с номерами от 1
до n
. Найти сумму элементов массива, вывести ее на экран.
Const n=10;
Var А: array [1..n] of integer;
sum,I:integer;
begin
sum:=0;
for i:=1 to n do sum:=sum+A[i];
writeln(‘Сумма элементов массива = ‘ ,sum);
end.
2. Найти произведение матрицы А
(размерности m на n) на число k
.
for i:=1 to n do
for j:=1 to m do
A[ i , j ] := A[ i , j ] * k;
5.2 Строковый тип
Строковый тип данных используется для представления строк. Любая строка является набором символов, обобщает понятие символьных массивов, позволяя динамически изменять длину строки. В этом состоит главное отличие строк от символьных массивов.
Данные строкового типа – это последовательности (цепочки) символов произвольной длины (от нуля до заданного числа – максимальной длины строки). Т.е. все символы в любой строке нумеруются целыми числами, начиная с единицы.
Определение переменной строкового типа производится с помощью служебного слова string, после которого в квадратных скобках указывается максимальная длина строки (может быть задана константой или отсутствовать, тогда по умолчанию используется максимальное число – 255):
| type slovo = string[10]; var str1 : slovo; str2 : string [100]; str3 : string; |
str3 := ‘Это строка, а не символьный массив’;
Если строковой переменной присваивается выражение, длина которого больше максимальной длины данной строки, то лишние символы просто отбрасываются, программа при этом не прерывается (т.е. такая ситуация не считается ошибочной).
Операции, определенные над данными строкового типа:
-
конкатенация
(+) – сложение строк (то же самое выполняет стандартная функция concat
(
str
1,
str
2, …,
strN
)
);
Например, возможен такой фрагмент:
str
1:=‘Иван’;
str
2:=‘Петрович’;
str:=str1 + ‘ ‘+ str2 + ‘
Сидоров
’;
writeln
(
str
);
На экран будет выведена строка: Иван Петрович Сидоров;
-
операции сравнения
(<, >, =, <>, >=, <=
). Сравнение строк происходит поэлементно, т.е. первый символ одной строки сравнивается с первым второй, если они не равны, то большей считается та строка, символ которой больше, если же символы оказались равными, то сравнивается второй со вторым и так далее пока не встретятся не равные символы.
Например, результат следующих операций – true
:
‘Иван’< ‘Иванова’
‘Кот’ > ‘Код’
‘Я’>’Ты’
-
доступ к отдельным элементам строки
производится аналогично доступу к элементам символьного массива – номер нужного элемента строки указывается после имени строковой переменной в квадратных скобках (например, str
3[4]
);
- стандартная функция length
(
str
)
(str – выражение строкового типа) – вычисление текущей длины строки str
;
- стандартная функция copy
(
str
,
i
,
j
)
(i
, j
– выражения целого типа) выделяет из строки str
подстроку длиной j
символов, начиная с позиции i
;
- стандартная процедура delete
(
str
,
i
,
n
)
(i, n – выражения целого типа) удаляет из строки str
подстроку длиной n символов, начиная с позиции i (необходимо отметить, что при выполнении данной процедуры строка str
изменится, укоротится на n
символов, соответственное изменится длина строки);
- стандартная процедура insert
(
str
1,
str
2,
i
)
(str
1
, str
2
– выражения строкового типа; i
– выражение целого типа) вставляет строку str
1
в строку str
2
, начиная с позиции i
(при выполнении данной процедуры строка str
2
изменится и её длина увеличится);
- стандартная функция pos
(
substr
,
str
)
(substr, str – выражения строкового типа) находит первое вхождение подстроки substr
в строку str
, результат – номер позиции строки str
, с которого начинается это вхождение.
Рассмотрим примеры перечисленных процедур и функций.
S1:=’algorithm’;
S2:=’go’;
x:=length(S1); {x=9}
S3:=copy(S1, 3, 4); {S3 примет значение ‘gori’}
delete(S1, 4, 2); {S1 примет значение ‘algithm’}
insert(S1, S2, 2); {S1не изменится, а S2 примет значение ‘galgorithm
o’}
insert(S2, S1, 2); {S2 не изменится, а S1 примет значение ‘ago
lgorithm’}
x:=pos(S2, S1); {x=3}.
5.3 Множественный тип
Понятие множества
в математике является одним из основных и обозначает некоторую неупорядоченную совокупность объектов, которые называются элементами
множества. Например, множество простых чисел, множество жильцов одной улицы, множество букв алфавита и т.д. Из приведенных примеров видно, что множества могут содержать подмножества
(множество жильцов одной улицы состоит из подмножеств людей, живущих в разных домах на этой улице).
Следует обратить внимание на две основных особенности множеств:
1) в множестве могут содержаться элементы только одного, базового
типа (например, множество простых чисел не может содержать еще и буквы);
2) порядок элементов множества не фиксируется.
Например, такая совокупность элементов {1, 2, abc, ‘!’} вообще не считается множеством, а совокупности {1, 2, 5, 8} и {8, 1, 5, 2} – эквивалентные множества.
Для представления такого типа данных в языке Pascal существует множественный тип
.
Множественный тип задается с помощью двух служебных слов – set
и of
- и следующего за ним базового типа. В качестве базового типа может быть любой дискретный тип, содержащий не более 256 значений. Если базовый тип – ограниченный целый, то значения должны быть в диапазоне от 0 до 255.
Например:
type
digits = set of 1..5;
var
s:digits;
Переменная s
может быть пустым множеством
(не содержащим ни одного элемента) либо может принимать значения:
1
2
5
1,2
4,5
1,3,5
и т.д.
Другой пример описания множества:
type
elemcolor = ( red, yellow, blue);
color = set of elemcolor;
Изображение значений множественного типа в языке Pascal строится следующим образом: элементы множества перечисляются через запятую, весь список заключается в квадратные скобки.
Например:
[] – пустое множество;
[1,2,5];
[red].
В качестве элементов в изображении множества допускаются выражения, тип которых должен совпадать с базовым типом. Кроме того, можно указывать диапазоны значений. Так например, следующие два множества эквивалентны: [1..3, 5] и [1,2,3,5].
Операции, определенные над множествами:
1. Объединение, пересечение и разность множеств
– эти операции обозначаются символами ‘+
’, ‘*
’, ‘-
’ соответственно и обозначают традиционные действия, принятые над множествами в математике:
- объединение множеств (A+B);
- пересечение множеств (A*B);
- разность множеств (A-B);
Например:
[10]+[100, 1000] = [10, 100, 1000];
[5..10]+[15] = [5, 6, 7, 8, 9, 10, 15];
[1..5]*[3..10] = [3..5];
[-10..10] - [-15..5] = [5..10].
2. Проверка принадлежности элемента множеству(
X
in
A
)
– булевская операция, результат которой - true
, если элемент X
содержится в множестве A
, false
– если не содержится. X имеет тот же тип, что и элементы множества A.
Например:
100 in [10, 100, 1000] = true;
X in [1,2,10] = true, если X=1 или X=2 или X=10.
Проверка на равенство, неравенство и включение двух множеств
. Эти операции обозначаются следующими знаками:
A = B – равенство множеств;
A <> B – неравенство множеств;
A <= B – множество A входит в множество B;
A >= B – множество B входит в множество A.
Например:
| операция
|
результат
|
| [1, 3, 5, 7] = [1, 3, 5] |
false |
| [1, 2, 3] = [3, 1, 2] |
true |
| [2, 6, 18, 56] >= [6, 18] |
true |
и т.д.
Пример программы с использованием множества
Пусть дана строка символов с точкой в конце строки. Нужно определить число различных букв, входящих в данную строку.
1-
й
вариант
var
M : set of char;
str : string;
c : char;
i,n : integer;
begin
M := []; {M – пустое множество}
n:=0; {переменная, считающая количество различных букв в строке}
writeln ( ‘ Введите строку ‘ );
readln ( str );
for i:=1 to length(str) do M := M + [str[i]]; {формирование множества, содержащего все буквы, входящие в строку}
for c := ‘A’ to ‘z’ do {Подсчет количества элементов
if (c in M) then n:=n+1; в множестве}
writeln ( ‘ Количество различных элементов в строке равно ‘,n);
end.
2-
й
вариант
var
M : set of char; str : string; c : char; i,n : integer;
begin
M := []; {M – пустое множество}
n:=0; {переменная, считающая количество различных букв в строке}
writeln ( ‘ Введите строку ‘ );
readln ( str );
for i:=1 to length(str) do
if not( str[i] in M) then
begin
M := M + [str[i]]; {формирование множества, содержащего все буквы, входящие в строку}
n:=n+1;
end;
writeln ( ‘ Количество различных элементов в строке равно ‘,n);
end.
5.4 Комбинированный тип (запись)
В программировании часто приходится использовать модель какого-либо объекта или явления. Для этого необходимо указать его характеристики. Например, характеристики окружности – координаты центра и радиус. Характеристики человека – имя, возраст, адрес и т.д. Данные, представляющие свойства объекта, чаще всего имеют разный тип, но все они логически связаны между собой – представляют один и тот же объект. Объединять данные разного типа в одну группу как раз и позволяет комбинированный тип (запись
).
Описание комбинированного типа представляет собой список описаний его элементов, которые называются полями. Каждое поле имеет свой идентификатор (имя).
Форма описания записей:
type
<имя типа> = record
<имя поля1> : <тип поля1>;
<имя поля2> : <тип поля2>;
.
.
.
end;
Поля могут иметь любой тип, в том числе они могут быть массивом или записью. Пример:
type
round = record
x,y:real;
R:real;
end;
var
circle1, circle2 : round;
Circles : array[1..5] of round;
Переменной типа запись можно присвоить только значение переменной такого же типа, т.е.
сircle1 := сircle2;
сircle2 := Circles[1];
Circles[5]:= Circles[3];
Для того чтобы присвоить значение какому-либо полю, необходимо указать имя переменной и имя поля, разделенные символом ".":
circle1.x := 5;
circle1.y := 8;
circle1.R := 2;
read(Circles[i].R);
writeln(Circles[i].x);
Легко заметить, что постоянно указывать имя записи не очень удобно. Чтобы облегчить работу программиста, существует оператор with
. Общий вид оператора with
:
with
<имя переменной> do
<оператор>;
В качестве оператора используется любой простой или составной оператор. В операторе имя записи указывать не обязательно, достаточно указать имя поля.
Теперь часть программы
circle1.x := 5;
circle1.y := 8;
circle1.R := 2;
можно переписать следующим образом.
with circle1 do
begin
x:=5; y:=8;R:=2;
end;
Пример программы с использованием записи
Сформировать список записей содержащих информацию о десяти студентах (фамилия, номер группы, 5 оценок за последнюю сессию). Вывести фамилии студентов имеющих средний балл больший или равный 4.
type
student = record
name:string[10];
group:integer;
ball:array[1..5] of 2..5; {массив, содержащий оценки}
srednball:real; {средний балл}
end;
var
st:array[1..10] of student;
I,j,d:integer;
begin
for i:=1 to 10 do
begin
writeln(‘Введите фамилию студента’);
readln(st[i].name);
writeln(‘Введите номер его группы’);
readln(st[i].group);
writeln(‘Введите пять оценок’);
for j:=1 to 5 do readln(st[i].ball[j]);
d:=0;
for j:=1 to 5 do d:=d+ st[i].ball[j];
st[i].srednball:=d/5;
end;
for i:=1 to 10 do
if st[i].srednball >=4 then writeln(st[i].name);
end.
6 Подпрограммы
6.1 Назначение подпрограмм
Понятие "подпрограмма
" встречается во многих языках программирования, поскольку является основным средством структурирования языка. Подпрограмма – это обособленная именованная часть программы. Использование подпрограмм позволяет:
1) сделать основную программу более наглядной и компактной;
2) уменьшить объем используемой памяти ЭВМ;
3) сократить время написания и отладки программы, так как различные подпрограммы могут быть написаны различными людьми параллельно.
Таким образом, подпрограмма – это часть операторов программы, выделенных в группу, оформленную в виде отдельной конструкции.
"Вызов подпрограммы" – выполнение действий, заданных в подпрограмме, может быть произведен в некоторой точке программы посредством указания имени этой подпрограммы.
6.2 Структура подпрограмм
Структура подпрограммы почти в точности повторяет структуру всей Pascal-программы.
При описании подпрограммы в общем случае необходимо задать три основные компоненты:
- интерфейс подпрограммы, т. е. информацию, необходимую для ее вызова;
- локальный контекст подпрограммы - совокупность описаний (рабочих) объектов, с которыми осуществляются действия;
- сами действия (операторы), составляющие смысл подпрограммы.
Интерфейс подпрограммы содержится в заголовке
и говорит о том, что именно
делает подпрограмма.
Две остальные компоненты называются телом подпрограммы и содержат информацию о том, как
выполняется подпрограммой то, что описано в ее заголовке.
В языке Pascal выделяют два вида подпрограмм: процедуры
и функции
. Различия процедур и функций заключаются в назначении и способе их использования.
Функции нужны для вычисления нового значения некоторого выражения, и вызов функции должен быть операндом в выражении.
Процедуры служат для задания последовательности действий и определения новых значений переменных в программе. Вызов процедуры играет роль оператора.
Описание процедур и функций в общем виде:
Заголовок процедуры:
procedure <имя> (список формальных параметров);
Заголовок функции:
function <имя> (список формальных параметров) : <тип результата>;
Тело подпрограммы – это блок, состоящий из двух частей: описание объектов и группа операторов. Более полный общий вид процедуры (общий вид функции отличается только заголовком):
procedure <имя> (список формальных параметров);
var
{раздел описания переменных}
begin
{операторы}
end;
6.3 Область действия имен
Переменные, представленные в разделе описания основной программы, могут быть использованы в теле основной программы и в любой ее подпрограмме. Эти переменные называются глобальными
. Переменные, описанные в подпрограмме, действуют только в теле данной подпрограммы и в любой, объявляемой внутри нее подпрограмме. Такие переменные называются локальными
. Они недоступны для операторов основной программ
Наглядно схему программы, имеющей некоторые вложенные подпрограммы, можно представить следующим образом:
Самый внешний блок программы обозначен буквой А
(имена этого блока "видны" во всех остальных блоках), B
и D
– подпрограммы, описанные во внешнем блоке, С
– подпрограмма, описанная в блоке B
(объекты этого блока известны только внутри самого блока).
При написании программ, имеющих вложенные подпрограммы, необходимо соблюдать следующие правила:
1) описывать имена переменных в том блоке, где они используются;
2) если одна и та же переменная используется в двух и более вложенных блоках, то описывать ее надо в самом внешнем из них;
3) если переменная, используемая в подпрограмме, должна сохранять свое значение при следующем вызове подпрограммы, то она должна быть описана во внешнем блоке;
4) каждый вызываемый блок должен быть описан до его вызова;
5) в Турбо-Паскале в одном модуле может быть описано не более 512 процедур или функций;
6) имена формальных параметров не должны совпадать с именами переменных внешнего блока.
6.4 Механизм параметров
В заголовке процедуры или функции может быть задан список формальных параметров
. Этот список указывается после имени подпрограммы в круглых скобках. Формальные параметры, описание которых похоже на описание переменных, в данной подпрограмме так же считаются локальными.
Идентификаторы формальных параметров можно считать условными обозначениями в теле подпрограммы тех реальных, фактических параметров, с которыми будет вызвана подпрограмма. При этом должны выполняться следующие требования:
- количество фактических и формальных параметров должно быть одинаковым;
- соответствующие фактические и формальные параметры должны совпадать по порядку следования и по типу.
Входными фактическими параметрами могут быть константы, переменные или выражения, выходными фактическими параметрами могут быть только переменные.
Параметры процедур бывают двух видов:
параметры – значения (входные параметры или параметры, передаваемые по значению). Формальные параметры в данном случае считаются обычными локальными переменными;
параметры – переменные (выходные параметры или параметры, передаваемые по ссылке). Эти параметры используются для передачи некоторых значений, вычисленных в подпрограмме, обратно в программу.
Если в качестве параметров используется массив, то предварительно нужно описать имя типа массива в разделе Type
, а затем использовать это имя при описания массива в качестве формального параметра. Рассмотрим пример.
Program parametr;
Var b,c,d:integer; {глобальные переменные}
{Описание процедуры. Формальные параметры х и
y
, где
x
–
параметр-значение,
y
–параметр-переменная.}
P
rocedure TTT(x:integer; var y:integer);
Var p:integer; {р – локальная переменная}
Begin
P:=10;
X:=x+p;
Y:=y+p;
{Вывод на экран значения глобальной переменной
b
}
Writeln('b in TTT=',b);
{Вывод на экран измененых значений переменных
x
и
y
}
Writeln('x in TTT=',x);
Writeln('y in TTT=',y);
End; {конец процедуры}
Begin {начало основной программы}
b:=8; c:=1; d:=2;
TTT(c, d); {вызов процедуры
TTT
c
фактическими параметрами с и
d
}
{Вывод на экран значений переменных c и d, после возврата из процедуры в основную программу}
Writeln('c =',c);
Writeln('d =',d);
Writeln (p); {При достижении компилятором данного оператора будет вызвана ошибка типа "
Unknown
identifier
" (см. 10.1), так как переменная р не видна за пределами процедуры}
End. {конец программы}
В результате выполнения данной программы на экран будет выведено:
b in TTT=8
x in TTT=11
y in TTT=12
c=1
d=12.
Обратите внимание, что значение переменной d, соответствующей параметру-переменной y
изменилось, в то время как переменная с
осталась равной 1.
Использование процедур и функций на примере вычисления площади выпуклого четырехугольника
Задание: вычислить площадь плоского четырехугольника, заданного длинами четырех сторон и диагонали.
Диагональ делит выпуклый четырехугольник на два треугольника, площадь каждого из которых можно вычислить по формуле Герона:
S = sqrt(p(p-a)(p-b)(p-c)),
где p=(a+b+c)/2.
Простейшее решение – дважды записать в программе вычисление площади треугольника, но этого повторения можно избежать при использовании подпрограмм. Запишем программу вычисления площади выпуклого четырехугольника с помощью процедуры без параметров:
Program F1;
var
AB,BC,CD,DA, AC,s1,s,a,b,c,p : real;
procedure TriangleSquare; {описание процедуры}
begin
p:=(a+b+c)/2;
s1:=sqrt(p*(p-a)*(p-b)*(p-c))
end;
begin
read(AB, BC, CD, DA, AC);
a:=AB; b:=BC; c:=AC;
TriangleSquare; {1-й вызов процедуры}
s := s1;
a:=DA; b:=AC; c:=CD;
TriangleSquare; {2-й вызов процедуры}
writeln(s+s1)
end.
В данной программе все переменные являются глобальными и поэтому любая из переменных доступна внутри процедуры TriangleSquare
. В данной программе выполняется два обращения к этой процедуре, непосредственно перед каждым обращением идет группа операторов присваивания, задающих значения переменных a
,
d
,
c
. Этого нагромождения операторов присваивания можно избежать, используя процедуру с параметрами.
Кроме того, в данной программе переменная p
используется как вспомогательная переменная внутри процедуры и в основной программе не нужна. Поэтому имеет смысл описать эту переменную внутри процедуры.
Запишем теперь эту же программу, но используя процедуру с параметрами.
Program F2;
var
AB, BC, CD, DA, AC, s1, s:real;
procedure TriangleSquare (a, b, c : real; var s : real); {описание процедуры}
var
p : real;
begin
p:=(a+b+c)/2;
s:=sqrt(p*(p-a)*(p-b)*(p-c))
end;
Begin
read(AB, BC, CD, DA, AC);
TriangleSquare(AB, BC, AC, s1); {1-й вызов процедуры}
TriangleSquare(DA, AC, CD, s); {2-й вызов процедуры}
writeln(s+s1)
end.
Переменные AB, BC, CD, DA, AC, s1, s остались глобальными, а переменная p теперь локальная, это значит что она недоступна за пределами процедуры. Не трудно заметить, что данная программа, записанная с помощью процедуры с параметрами, гораздо нагляднее, понятнее, компактнее, чем программа, записанная с использованием процедуры без параметров, и, тем более, без использования подпрограмм. Но в случае, когда имеется только один выходной параметр, гораздо удобнее использовать другой вид подпрограммы – функцию
. Так при использовании функции вычисления площади треугольника методом Герона данная программа будет выглядеть следующим образом.
Program F2;
var
AB, BC, CD, DA, AC : real;
function TriangleSquare(a, b, c : real) : real; {описание функции}
var
p : real;
begin
p:=(a+b+c)/2;
TriangleSquare:=sqrt(p*(p-a)*(p-b)*(p-c))
end;
Begin
read(AB, BC, CD, DA, AC);
writeln(TriangleSquare(AB, BC, AC)+TriangleSquare(DA, AC, CD));
End.
Использование процедур и функций на примере упорядочивания
элементов массива
Во многих практических задачах требуется упорядочить данные каким-либо образом. Например, сформировать список фамилий студентов по алфавиту, расположить файлы в порядке возрастания их размеров и т.д. Процесс упорядочивания данных называется сортировкой. Существуют различные методы сортировок. В данном примере мы познакомимся с сортировкой методом выбора. Задача заключается в том, чтобы отсортировать исходный массив целых чисел, так чтобы элементы располагались в нем в порядке возрастания. Для этого в массиве выбирается минимальный элемент и меняется местами с элементом, стоящим на первом. Затем минимальный элемент ищется среди оставшихся элементов, начиная со второго, и меняется местами с элементом, стоящим на втором месте. Процедура продолжается до тех пор, пока в неупорядоченной части массива остается больше одного элемента. Пусть задан массив В=(20,-5,10,8,7), тогда шаги сортировки будут выглядеть следующим образом:
| B= |
20 |
-5
|
10 |
8 |
7 |
| B= |
-5 |
20 |
10 |
8 |
7
|
| B’= |
-5 |
7 |
10 |
8
|
20 |
| B’= |
-5 |
7 |
8 |
10
|
20 |
| B’= |
-5 |
7 |
8 |
10 |
20 |
На каждом шаге алгоритма требуется находить минимальный элемент в неупорядоченной части массива. Поэтому будет удобным оформить нахождение номера минимального элемента в виде функции, входным параметром, которой будет номер первого элемента в неупорядоченной части массива. Результатом, возвращаемым функцией, является номер минимального элемента в заданной части массива. Функция используется внутри процедуры выполняющей сортировку, на вход которой подается массив, и число элементов в нем. Алгоритм сортировки представлен блок-схемой:
Ниже приводится листинг программы, использующей процедуру sort() для сортировки массива заполненного случайными числами.
const m=100;
type mas=array[1..m] of integer;
procedure sort(var b:mas;n:integer);{Заголовок процедуры}
function number_min(k:integer):integer; {Заголовок функции}
var j,min,r:integer;
begin {тело функции}
r:=k;
for j:=k+1 to n do
if b[j]<b[r] then r:=j;
number_min:=r;
end;
var i,d,nmin:integer;
begin {тело процедуры}
for i:=1 to n-1 do
begin
nmin:=number_min(i); {вызов функции}
d:=b[i];
b[i]:=b[nmin];
b[nmin]:=d;
end;
end;
{Основная программа}
var a:mas;
i,n:integer;
begin
read(n);
for i:=1 to n do a[i]:=random(100);
for i:=1 to n do write(a[i],’ ‘);
sort(a,n);{Вызов процедуры}
writeln;
for i:=1 to n do write(a[i],’ ‘);
end.
7 Файловые типы
7.1 Файлы. Файловые переменные
Очень часто в ходе выполнения программы возникает необходимость записи информации на магнитный носитель (гибкий, жесткий диски). Запись особенно нужна, если объем информации велик и если в дальнейшем предполагается использовать эту информацию в других программах.
В языке Pascal для работы с внешними устройствами предусмотрены специальные компоненты – файлы
. Под файлом обычно понимается область памяти на внешнем запоминающем устройстве (дискета, жесткий диск), способная хранить информацию. С другой стороны файл это – структурный тип данных к элементам которого возможен последовательный доступ.
Для работы с файлом при описании переменных необходимо определить переменную файлового типа, которая будет считаться "представителем" этого файла в данной программе. Такая переменная называется также указателем. Описание файловой переменной может быть произведено следующим способом:
var
<имя файла> : file of <базовый тип>.
В качестве базового типа можно использовать любой тип, за исключением типа file, например:
type
Person = record
FirstName : string[15];
LastName : string[25];
Address : string[35]
end;
PersonFile = file of Person;
NumberFile = file of integer;
Доступ к элементам файла осуществляется последовательно через указатель файла, в отличии от массивов, где возможен прямой доступ к любому элементу по его номеру. Указатель всегда "указывает" на конкретный элемент файла, поэтому существует понятие "текущий указатель". Графически это можно представить следующим образом:
Обычно все действия с файлами производятся поэлементно, причем с тем элементом файла, на который указывает текущий указатель. При записи или считывании указатель перемещается к следующему элементу.
Поскольку число элементов файла не задается, то последним элементом файла всегда записывается символ конца файла (eof
). В языке Pascal существует булевская функция eof(<файловая переменная>)
, результат которой - true
, если указатель указывает на конец файла.
7.2 Основные операции с файлами
Установочные и завершающие операции
Эти операции необходимы на начальном этапе работы с файлами – для связывания файловой переменной с конкретным файлом, указания того, какие действия будут с ним проводиться и окончания работы с файлом. К ним относят:
1. assign (
f,
FileName)
– связывает файловую переменную f
с конкретным файлом с именем FileName
. Процедуру assign необходимо использовать всегда до начала работы с файлом. FileName
– выражение строкового типа, вида
Диск:имя каталогаимя подкаталога…имя файла.
Если имя диска и имя каталога не указывать, то берутся текущий диск и текущий каталог.
2. reset (
f)
– открывает файл f
для чтения, т.е. указатель устанавливается на первый элемент файла. Предполагается, что открываемый файл уже существует, в противном случае возникает ошибка.
3. rewrite (
f)
– открывает файл f
для записи (указатель так же, как и в предыдущем случае, устанавливается на первый элемент файла). Допускается, что открываемый файл не существует, тогда процедура создает файл с заданным именем. Если же такой файл существует, процедура удаляет из него всю информацию. В обоих случаях в результате вызова данной процедуры файловая переменная указывает на нулевой элемент файла (т.е. файл пуст).
close (
f)
– закрывает файл f
, очищает внутренний буфер, образованный при открытии файла. Теперь указатель f
можно связать с другим файлом.
Операции ввода-вывода
Это две операции:
а) read (
f, х1, х2, …)
считывает в переменные x1,
x2, …
по одному элементу из файла f
, начиная с той позиции, на которую установлен указатель. Операция чтения осуществляется следующим образом: значение, на которое указывает текущий указатель файла, присваивается переменной x1
, указатель перемещается на следующую позицию, то же самое выполняется для переменной x2
, и т.д. Процедура read выполнима только в том случае, если не достигнут конец файла (eof (
f ) =
false
);
в) write
(
f
,
x
1,
x
2, …)
записывает в файл f значения переменных x
1
, x
2
, …
, начиная с той позиции, на которую указывает файловая переменная. После записи в файл нового элемента, указатель перемещается на следующую позицию. Функция write
выполнима только в том случае, когда достигнут конец файла (eof
(
f
) =
true
).
Операции перемещения по файлу
В эту группу входят:
-
seek(
f,
N)
– функция, позволяющая явно изменить значение текущего указателя, установив его на элемент файла с заданным номером N
(N
– целочисленное выражение). Процедура seek не выполняет чтения или записи элементов файла, она лишь перемещает указатель к элементу с номером N
. (Первый элемент файла имеет номер 0). Вызов процедуры с аргументами seek (
f,
filesize (
f ) )
установит указатель на конец файла;
-
filepos (
f) –
функция, позволяющая определить текущее положение указателя (номер элемента);
-
filesize (
f)
–
функция, позволяющая определить размер (количество элементов) файла f;
-
eof (
f)
–
функция, возвращающая логическое значение true
, если достигнут конец файла.
Специальные операции
Эта группа предназначена для действий с каталогами и именами. Некоторые из операций:
erase (
f)
удаляет файл, связанный с файловой переменной f;
rename (
f,
NewName)
присваивает файлу, связанному с файловой переменной f, новое имя NewName
.
7.3 Примеры работы с файлами
В качестве примеров рассмотрим три наиболее часто встречающихся действия с файлами:
1. Чтение данных из файла.
Для чтения файла необходимо выполнить следующий алгоритм:
1) связать файл с файловой переменной;
2) открыть файл для чтения;
3) ввести данные файла в память;
4) закрыть файл.
Пример программы, реализующий этот алгоритм:
Program Read_File;
var
F : file of char;
Ch : char;
FileName : string;
begin
write (‘ Введите имя файла : ‘);
readln ( FileName );
assign( F, FileName );
reset( F );
while not eof ( F ) do
begin
read(F, Ch);
write( Ch )
end;
close( F )
end.
После того, как мы связали файл с файловой переменной с помощью оператора assign
(
f
,
FileName
)
, открываем файл с помощью оператора reset
(
f
)
. В результате файловая переменная f указывает на первый элемент файла:
С помощью оператора
read
(
F
,
Ch
);
в переменную Ch
считывается значение, которое находится в том месте файла, на которуе указывает переменная F
, т.е. С
. Затем указатель перемещается на следующий элемент файла.
После этого значение переменной Ch
выводится на экран с помощью оператора
write
(
Ch
);
Затем аналогичным образом считываются из файла значения 2-го, 3-го и т.д. элементов до тех пор, пока файловая переменная не будет указывать на конец файла.
2. Запись данных в файл.
Алгоритм записи данных в файл можно определить следующим образом:
1) связать файл с файловой переменной;
2) открыть файл для записи;
3) записать данные из программы в файл;
4) закрыть файл для записи.
Пример программы, реализующей этот алгоритм и записывающей в файл числа от 1 до 30:
Program Write_File;
var
F : file of integer;
i : integer;
FileName : string;
begin
write (‘ Введите имя файла : ‘);
readln ( FileName );
assign(F, FileName);
rewrite ( F );
for i := 1 to 30 do
write ( F , i );
close ( F )
end.
При открытии файла с помощью процедуры rewrite
(
f
)
файл выглядит следующим образом:
Так как файловая переменная указывает на конец файла, мы можем записать в него любую информацию, с помощью процедуры write
, например,
i:=1;
write( f, i);
i:=i+1;
write( f, i);
и так далее. Необходимо отметить, что в отличии от вывода на экран, при записи информации в файл вторым аргументом оператора write являются не выражения, а переменные. Следующие записи будут неверны: write(f,1), write(f, x+1).
3. Добавление данных к файлу.
Пусть необходимо к уже существующему файлу добавить ряд элементов. Для этого необходимо выполнить следующие действия:
1) открыть уже существующий файл с помощью процедуры reset
(
f
)
;
2) установить указатель файла на последний элемент с помощью процедуры seek следующим образом: seek
(
f
,
filesize
(
f
) );
3) записать дополнительные данные;
4) закрыть файл.
Например: к уже имеющемуся файлу, в который занесены числа от 1 до 30, дописать числа 40,50,60,70,80.
Program Append_File;
var
F : file of integer;
i : integer;
FileName : string;
begin
write ( ‘Введите имя файла : ‘);
readln ( FileName );
assign(F, FileName);
reset(F);
seek (F , FileSize( F ));
for i:=4 to 8 do
write(F, i*10);
close(F)
end.
При открытии файла с помощью процедуры reset
вся информация в файле остается без изменения, курсор устанавливается на первый элемент файла:
Затем с помощью операции seek
(
F
,
FileSize
(
F
));
перемещаем файловую переменную на последний элемент файла:
Так как файловая переменная указывает на конец файла, мы можем дописать в файл любую информацию, например, с помощью оператора write
(
f
,31);
7.4 Текстовые файлы
Описание
текстовых файлов
Отдельным типом файлов являются текстовые файлы. Особенность этих файлов заключается в том, что их содержимое рассматривается как последовательность строк переменной длины, разделенных специальными символами, которые называются "конец строки". Символ конца строки при просмотре файла не виден, так же как и символ конца файла. Так же, как и в случае с файлами, в программе должна быть описана файловая переменная, имеющая тип text
:
var
<имя файловой переменной> : text;
Главная особенность текстовых файлов в том, что можно считывать из него и записывать в них элементы типа c
har,
i
nteger,
r
eal,
s
tring,
b
oolean
.
Процедуры и функции для работы с текстовыми файлами
Для работы с текстовыми файлами можно использовать все процедуры и функции, используемые при работе с файлами любых типов, за исключением процедуры seek, функций filepos
, filesize
. Дело в том, что заранее неизвестно, элементы какого типа находятся в файле.
Например, если в файле находится символ 5, то мы можем его считать как real
,
integer
,
char
,
string
размером 1. В этом случае они будут занимать
real – 4 байта;
integer – 2 байта;
char – 1 байт;
string – 1 байт.
Если в файле находится число 3.24897224E-06, то его можно рассматривать как элемент типа real
или string
размером 14 символов. Размер в байтах в этих случаях будет составлять:
real – 4 байта;
string – 14 байт.
Для работы с текстовыми файлами определены дополнительные операции.
Функция:
eoln ( f )
– логическая функция, возвращающая значение true
, если достигнут конец строки, и false
в противном случае;
процедуры:
append ( f )
– открытие уже существующего текстового файла f
для добавления данных в конец файла;
writeln ( f )
– завершение текущей строки текстового файла при его записи (записывает символ конца строки);
writeln ( f, x1, x2, …, xn)
– запись в файл f значений переменных x1, x2, …, xn
; после выполнения операции записи осуществляется переход к новой строке файла;
readln ( f )
– переход к началу следующей строки файла f
при его чтении;
readln ( f, x1, x2, …, xn)
– чтение значений n элементов из файла f
в переменные x1, x2, …, xn
; после выполнения операции записи осуществляется переход к новой строке файла.
8 Модули. Графика
8.1 Организация модулей
Необходимость в использовании модулей или, другими словами, модульном программировании возникла в первую очередь из-за трудностей, связанных с огромными объемами программ, их сложностью и потребностью в коллективной работе. Модули значительно расширяют возможности языка. По определению, модуль считается отдельной программой, его структура аналогична структуре программы – он представляет собой набор констант, типов данных, переменных, процедур и функций. Вместе с тем структура модуля позволяет использовать его как своеобразную библиотеку описаний. Каждый модуль записывается в отдельном файле с расширением tpu
.
Заголовок модуля начинается со служебного слова unit
, заканчивается символом ";
". Все программные ресурсы модуля делятся на две части: объекты, предназначенные для использования программами или другими модулями, и объекты рабочего характера. Поэтому, кроме заголовка, модуль состоит еще из двух частей: интерфейса и реализации.
Интерфейсная часть включает описание объектов, доступных из других программ; эти объекты называются видимыми. В части реализации находятся невидимые (скрытые) объекты. Кроме этого, модуль может содержать раздел инициализации, если перед использованием модуля необходимо установить значения каких-либо переменных. Общая схема структуры модуля выглядит следующим образом:
unit <имя модуля>;
interface
<описание видимых объектов>
implementation
<описание скрытых объектов>
begin
<операторы инициализации объектов модуля>
end.
В качестве объектов в модуле можно использовать процедуры и функции. Для этого в интерфейсной части модуля необходимо описать заголовки подпрограмм и видимые переменные, а в части реализации – должны быть полные описания подпрограмм.
Чтобы иметь возможность использовать интерфейсные объекты модуля в своей программе, нужно указать имя (или список имен модулей, перечисленных через запятую) соответствующего tpu-файла после служебного слова uses
:
uses
Unit1, Unit2, Unit3;
В языке Pascal 6.0 есть восемь стандартных модулей: SYSTEM, DOS, CRT, PRINTER, GRAPH, OVERLAY, TURBO3
и
GRAPH3
. Из них только модуль SYSTEM
подключается автоматически к любой программе.
Краткая характеристика модулей:
- Модуль SYSTEM
включает все стандартные процедуры и функции языка Pascal и встроенные процедуры и функции языка Turbo Pascal. Подключается к любой программе автоматически, не требуя объявления.
- Модуль PRINTER
отвечает за вывод текстов на принтер.
- Модуль CRT
обеспечивает управление текстовым режимом работы экрана (перемещение курсора в любую позицию экрана, изменение цвета символов, фона, управление звуком).
- Модуль GRAPH
обеспечивает управление графическим режимом работы экрана (позволяет создавать и выводить на экран графические изображения и текстовые надписи).
- Модуль DOS
отвечает за доступ программ к средствам дисковой операционной системы MS DOS.
- Модуль OVERLAY
необходим при разработке больших программ, требующих большого количества памяти.
- Модули TURBO3
и GRAPH3
созданы для совместимости с ранней версией 3.0 системы Turbo Pascal.
8.2 Модуль Graph
Для вывода графических изображений на экран монитора в языке Pascal существует стандартная библиотека Graph
, подключение которой осуществляется стандартным способом:
uses
Graph;
В графическом режиме работы любое изображение на экране дисплея состоит из множества мельчайших элементов, называемых пикселами. Каждый пиксел - это светящаяся точка таких размеров, при которых промежуток между соседними пикселами отсутствует.
В графическом режиме экран дисплея представляет собой прямоугольную сетку координат. Левый верхний угол экрана имеет координаты (0,0), правый (для адаптера VGA) – (639,479), соответственно центр экрана имеет координаты (319,239). Значение координаты х увеличивается слева направо, координаты у - сверху вниз. В этом режиме курсор невидим, но всегда присутствует.
Образ любого изображения, высвечиваемого на экране монитора с помощью совокупности пикселов, хранится в специальной области памяти – видеопамяти.
Реализация графического режима в ЭВМ обеспечивается с помощью графического адаптера. Работу графического адаптера поддерживает драйвер адаптера (файл с расширением *.bgi). Для современных графических адаптеров VGA и EGA используется драйвер EGAVGA.BGI.
Самостоятельная работа по теме "Модуль
Graph
"
1. Нарисовать рисунок. Голову и туловище закрасить собственной штриховкой.
2. Сделать рисунок двигающимся, при этом ноги и хвост должны шевелиться.
1. Нарисовать рисунок. Кольца дыма закрасить собственной штриховкой.
2. Сделать рисунок двигающимся, при этом из трубы должен идти дым.
1. Нарисовать рисунок. Голову и туловище закрасить собственной штриховкой.
2. Сделать рисунок двигающимся, при этом ноги, хвост и крылья должны шевелиться.
1. Нарисовать рисунок. Голову и туловище закрасить собственной штриховкой.
2. Сделать рисунок двигающимся, при этом ноги и руки должны шевелиться.
1. Нарисовать рисунок. Кабину вертолета закрасить собственной штриховкой.
2. Сделать рисунок двигающимся, пропеллеры должны крутиться.
1. Нарисовать рисунок. Голову и туловище закрасить собственной штриховкой.
2. Сделать кузнечика прыгающим, при этом ноги и руки должны шевелиться.
1. Нарисовать рисунок. Голову и туловище закрасить собственной штриховкой.
2. Сделать зайца прыгающим, при этом ноги и руки должны шевелиться.
1. Нарисовать рисунок. Голову и туловище закрасить собственной штриховкой.
2. Сделать рисунок двигающимся, при этом ноги и руки должны шевелиться.
1. Нарисовать рисунок. Голову и туловище закрасить собственной штриховкой.
2. Сделать рисунок двигающимся, при этом ноги должны шевелиться.
1. Нарисовать рисунок. Голову и туловище закрасить собственной штриховкой.
2. Сделать рисунок двигающимся, при этом ноги и руки должны шевелиться.
1. Нарисовать рисунок. Голову и туловище закрасить собственной штриховкой.
2. Сделать рисунок двигающимся, при этом ноги должны шевелиться.
8.3 Инициализация и выход из графического режима
Для того чтобы работать с графикой, сначала необходимо установить подходящий для данного монитора видеорежим. Это производится с помощью стандартной процедуры:
procedure InitGraph(var GraphDriver:Integer; var GraphMode: Integer;
PathToDriver: string);
Переменная GraphDriver
задает тип загружаемого драйвера (если тип драйвера неизвестен, этой переменной можно присвоить результат стандартной функции detect
: GraphDriver:=detect
).
Переменная GraphMode
задает режим работы драйвера (для VGA лучший режим –VGAHi(2), для EGA – EGAHi (1)). Если для определения переменной GraphDriver
была использована функция detect
, то процедура InitGraph
сама установит подходящий режим.
В переменной PathToDriver
задается путь к графическому драйверу, который содержится в файле egavga.bgi. Если поместить этот файл в текущий каталог, то путь можно не прописывать, указав в функции InitGraph
пустую строку (например: InitGraph
( GraphDriver,
GraphMode, ‘’
)). В противном случае необходимо указать полный путь к файлу (например: InitGraph
( GraphDriver,
GraphMode, ‘
С:ProgramsBPBGI’)). Ошибки, которые могут возникать в процессе инициализации графического режима, анализируют с помощью функции GraphRezult
.
Для завершения работы с графикой необходимо использовать стандартную процедуру CloseGraph
. При этом освобождается выделенная для работы с графикой память и восстанавливается режим работы адаптера.
Пример инициализации графического режима:
uses Graph;
var
grDriver, grMode, ErrCode: Integer;
begin
grDriver := Detect;
InitGraph(grDriver, grMode, ‘‘);
ErrCode := GraphResult;
if ErrCode = grOk then
begin
{ Выполнение работы в граф. режиме }
CloseGraph;
end
else Writeln(‘Ошибка:’, GraphErrorMsg(ErrCode));
end.
8.4 Вывод некоторых графических примитивов
Модуль Graph позволяет выводить на экран изображение различных простых геометрических фигур (примитивов), а также получать информацию о них. Это осуществляется с помощью следующих процедур и функций:
Arc
(
X
,
Y
,
StAngle
,
EndAngle
,
Radius
:
integer
)
рисует дугу с центром в точке (X, Y), от начального угла StAngle до конечного EndAngle, радиусом Radius;
Bar
(
X
1,
Y
1,
X
2,
Y
2 :
integer
)
выводит на экран закрашенный прямоугольник с координатами левого верхнего угла (Х1,У1) и правого нижнего угла (Х2,У2);
Bar
3
D
(
X
1,
Y
1,
X
2,
Y
2 :
integer
;
Depth
:
word
;
Top
:
boolean
)
выводит на экран трехмерную полосу, используя текущий стиль и цвет;
Circle
(
X
,
Y
,
Radius
:
integer
)
- выводит на экран изображение окружности с центром (X,Y), радиусом Radius;
DrawPoly
(
NumPoints
:
word
;
var
PolyPoints
)
рисует многоугольник из NumPoints вершин с координатами в PolyPoints, текущим цветом и типом линии;
Ellipse
(
X
,
Y
:
integer
;
StAngle
,
EndAngle
,
XR
,
YR
:
word
)
рисует эллиптическую дугу от начального угла StAngle до конечного EndAngle, используя X,Y как координаты центра, XR,YR – как горизонтальный и вертикальный радиусы;
FillEllipse
(
X
,
Y
,
Xradius
,
Yradius
:
integer
)
выводит на экран изображение полного закрашенного эллипса с центром X,Y, с горизонтальной и вертикальной полуосями Xradius,Yradius;
FillPoly
(
NumPoints
:
word
;
var
PolyPoints
)
рисует и штрихует многоугольник из NumPoints вершин с координатами в PolyPoints;
Line
(
X
1,
Y
1,
X
2,
Y
2 :
integer
)
выводит на экран линию, соединяющую точки с координатами (X1,Y1) и (X2,Y2);
LineTo
(
X
,
Y
:
integer
)
выводит на экран линию, соединяющую точку, в которой находится курсор, с точкой (X,Y);
PutPixel
(
X
,
Y
,
Color
:
integer
)
выводит на экран пиксел в точке X,Y, цветом Color;
Rectangle
(
X
1,
Y
1,
X
2,
Y
2 :
integer
)
выводит на экран изображение прямоугольника.
8.5 Управление
графическими элементами
Чтобы изменять цвет рисования (совокупность цветов называется палитрой,
она может быть как стандартной, так и определенной программистом), тип и толщину линий, способ заливки, в модуле Graph определен набор констант, процедур и функций. Основные процедуры из этого набора:
SetBkColor
(
Color
:
integer
)
устанавливает текущий фоновый цвет Color;
SetColor
(
Color
:
integer
)
устанавливает основной цвет рисования;
GetColor
:
word
– функция, возвращающая текущий цвет;
GetBkColor
:
word
– функция, возвращающая текущий фоновый цвет;
SetLineStyle(LineStile, Pattern, Thinkness : integer)
определяет стиль и толщину линии.
SetPalette(ColorNum, Color : word)
заменяет цвет палитры с номером ColorNum на цвет Color;
SetFillPattern(Pattern : FillPatternType; Color : word) позволяет установить произвольный образец штриховки;
SetFillStile(Pattern, Color : integer)
устанавливает образец штриховки и цвет;
FloodFill(X, Y : integer; Border : word)
штрихует замкнутую область содержащую внутреннюю точку с координатами X,Y и ограниченную линией с цветом Border. Используется текущий образец штриховки и цвет;
GetDefaultPalette
(
var
Palette
:
PaletteType
)
возвращает текущую палитру в записи PaletteType;
GetFillPattern
(
var
FillPatt
:
FillPatternType
)
возвращает текущий образец штриховки;
GetLineSettings
(
var
LineInfo
:
LineSettingsType
)
возвращает текущий стиль, шаблон и толщину линии;
GetPalette
(
var
Palette
:
PaletteType
)
возвращает текущую палитру и ее размер.
Для определения цвета выводимых на экран различных геометрических фигур в модуле Graph описаны константы, представленные в таблице 8.1.
Таблица 8.1 – Константы цвета
| Название константы (цвет) |
Значение |
Название константы (цвет) |
Значение |
| Black (черный) |
0 |
DarkGray (темно-серый) |
8 |
| Blue (синий) |
1 |
LightBlue (ярко-синий) |
9 |
| Green (зеленый) |
2 |
LightGreen (ярко-зеленый) |
10 |
| Cyan (голубой) |
3 |
LightCyan (ярко-голубой) |
11 |
| Red (красный) |
4 |
LightRed (розовый) |
12 |
| Magenta (фиолетовый) |
5 |
LightMagenta (малиновый) |
13 |
| Brown (коричневый) |
6 |
Yellow (желтый) |
14 |
| LightGray (светло-серый) |
7 |
White (белый) |
15 |
Для задания стиля и толщины линии определены константы, приведенные в таблице 8.2.
Таблица 8.2 - Константы типов и толщины линий:
|
Название константы |
Изображение линии |
Значение константы |
| SolidLn |
|
0 |
| DottedLn |
1 |
|
| CenterLn |
2 |
|
| DashedLn |
3 |
|
| UserBitLn |
Тип, определяемый пользователем |
4 |
Толщина линии может быть задана следующими константами:
· нормальная толщина – 1 (NormWidth
);
· тройная толщина – 3 (ThickWidth
).
Шаблон (Pattern) выбирается из констант, приведенных в таблице 8.3.
Таблица 8.3 – Константы шаблона штриховки
| Название константы |
Значение |
Тип штриховки |
| EmptyFill |
0 |
Нет штриховки |
| SolidFill |
1 |
Сплошная штриховка |
| LineFill |
2 |
|
| LtSlashFill |
3 |
///// |
| SlashFill |
4 |
/////
|
| BkSlashFill |
5 |
(толстыми линиями) |
| LtBkSlashFill |
6 |
|
| HatchFill |
7 |
+++++ |
| XHatchFill |
8 |
xxxxxx |
| InterleaveFill |
9 |
штриховка в клетку |
| WideDotFill |
10 |
штриховка редкими точками |
| CloseDotFill |
11 |
штриховка частыми точками |
| UserFill |
12 |
задается пользователем |
Если выбрано значение UserFill
, то устанавливается шаблон, заданный в SetFillPattern
.
8.6 Управление графическим курсором
Курсор в графическом режиме представляет собой точку с координатами (X,Y). Для управления курсором определены следующие процедуры и функции:
ClearDevice
очищает экран;
GetMaxX
возвращает максимальное значение координаты X;
GetMaxY
возвращает максимальное значение координаты Y;
GetX
возвращает координату Х курсора;
GetY
возвращает координату Y курсора;
MoveRel
(
Dx
,
Dy
:
integer
)
перемещает курсор в точку, которая находится на расстоянии Dx, Dy от курсора;
MoveTo
(
X
,
Y
:
integer
);
перемещает указатель в точку X,Y.
8.7 Вывод текстовой информации
В графическом режиме вывод текстовой информации осуществляется с помощью шрифтов
. Шрифты описаны в файле с расширением CHR.
Вывод текстовой информации в графическом режиме осуществляется с помощью следующих процедур:
OutText
(
TextString
:
string
)
- вывод строки TextString начиная с текущей позиции курсора;
OutTextXY
(
X
,
Y
:
integer
;
TextString
:
string
)
- вывод строки TextString, начиная с позиции с координатами X,Y.
9 Ссылочные типы. Динамические переменные
9.1 Динамическая память. Статические и динамические переменные
Динамическая память – это область памяти, которая выделяется программе при ее работе. В одной части этой области (обычно это 65536 байт), которая называется сегментом данных, размещаются переменные, объявленные в программе, в оставшейся части – собственно тела программы.
Размер динамической памяти ограничивается лишь доступной памятью компьютера, и бывают такие ситуации (например, при написании программ, обрабатывающих огромное количество данных), когда размер такой памяти мал. В таких случаях единственный выход – использование динамических переменных вместо статических.
Переменные, память под которые распределяется при вызове программы, в которой они написаны, и освобождается при окончании работы программы, называются статическими
. Таким образом, статическое размещение данных осуществляется компилятором в процессе компиляции программы. Переменные, создает и уничтожает которые сам программист, называются динамическими
. При динамическом размещении данных заранее неизвестны тип и количество размещаемых данных, обращение к ним производится не с помощью имени, как при статическом размещении, а с помощью указателей.
Создание и уничтожение динамических переменных осуществляется соответственно стандартными процедурами new
(
p
)
и dispose
(
p
)
, p
– указатель на динамическую переменную:
var
p := ^char;
begin
new(p);
{операторы}
dispose(p)
end.
9.2 Понятие ссылочных типов и указателей
Ссылочные (указательные) типы не относятся ни к скалярным, ни к составным типам, так как, с одной стороны, являются атомарными (неделимыми), с другой стороны - определяются через другие типы.
Переменные ссылочного типа являются указателями
на значения некоторого определенного типа. При описании указателей используется символ "^". В общем виде:
type
<имя ссылочного типа> = ^<базовый тип>;
Т.е. указатели содержат адреса расположения в памяти конкретных значений базового типа.
Например:
type
Pointer = ^char;
Это описание определяет тип Pointer, множество значений которого – указатели на данные символьного типа. В качестве базового можно также использовать тип, который еще не описан.
Кроме этого, в языке Pascal есть понятие "пустого указателя", который никуда не указывает и обозначается служебным словом nil. Это значение можно присваивать любому типу.
Чтобы присвоить переменной ссылочного типа некоторое значение, используют операцию "взятие указателя", которая обозначается символом "@". Эта операция допустима для любых переменных. Например:
type
Pointer = ^integer;
var
mas := array[1..10] of integer;
p := pointer;
begin
read(mas[1]);
p := @mas[1]
end.
Теперь доступ к переменной mas
[1]
может быть осуществлен двумя способами: по идентификатору (прямой доступ, непосредственно mas
[1]
) и через указатель (косвенный доступ, p
^
- эта запись означает "переменная, на которую ссылается p"). Поэтому следующие две записи эквивалентны:
mas[1] := mas[1] + 2;
и
p^ := p^ + 2;
Конструкция "p
^
" называется разыменованием
.
9.3 Списки
С помощью динамических переменных можно создавать такие структуры, как линейные списки (например, односвязные; разновидности таких списков – стеки и очереди).
Графически односвязный список можно представить следующим образом:
Здесь p
– указатель на список, указывает на конкретный элемент списка (в данном случае - на первый).
Описание такой структуры:
type
pointer = ^data;
data = record
info : string;
next : pointer
end;
var
p : pointer;
Заметьте, что в данном случае для описания типа pointer используется тип data, который еще не определен и описывается ниже. Это единственное допускаемое в языке Паскаль исключение, когда при описании типа используется тип описанный ниже.
Перемещать указатель по списку можно с помощью операции
p := p^.next;
После выполнения этого действия список будет выглядеть:
Пример программы, создающей список:
type
pointer = ^data;
data = record
info : string;
next : pointer
end;
var
p, p1 : pointer;
begin
p1 := nil; {p1 - пустой список}
while p^.string<>‘!’ do
begin
new(p);
p^.next:=p1;
read(p^.info);
p1:=p
end;
end.
Пример программы, реализующей операцию добавления в начало списка:
type
pointer = ^data;
data = record
info : string;
next : pointer
end;
var
p, p1 : pointer;
begin
new(p);
p^. info:= ‘data4’;
p^. next:= p1;
p1:=p;
Стек
– это линейный список, в котором все добавления и удаления элементов производятся обычно в начало списка.
Очередь
– это линейный список, в который элементы добавляются всегда в начало, а удаляются с конца.
Помимо этого, очень часто используются двусвязные списки
, которые в графическом виде можно представить следующим образом:
Описание такого списка:
type
pointer = ^data;
data = record
info : string;
left, right : pointer
end;
В этом случае у каждого элемента есть, помимо поля, содержащего данные, еще два – left
и right
; left указывает на предыдущий элемент, right – на следующий. Это дает огромное преимущество по сравнению с линейными списками – позволяет перемещаться по списку не только вперед, но и назад.
10 Программа Turbo Pascal
10.1 Основы работы с программой
После того, как программист напишет текст программы, его необходимо перевести на язык, понятный компьютеру – в машинные коды или откомпилировать. Эту задачу выполняет специальная программа – компилятор. Мы рассмотрим компилятор фирмы Borland – Turbo Pascal. Turbo Pascal состоит из текстового редактора, в котором мы можем набирать текст программы, компилятора и отладчика.
Не существует таких программистов, которые пишут программы, способные компилироваться и работать без ошибок (за исключением, может быть, самых простых и коротких). Поэтому после написания программы идет ее отладка. Отладка, как правило, занимает гораздо больше времени, чем непосредственное написание программы. Отладка выполняется с помощью специальной программы – отладчика. Программист шаг за шагом выполняет текст своей программы, при этом ему доступны значения всех переменных.
Итак, после запуска Turbo Pascal на экране монитора появляется окно, показанное на рис.10.1
Рис.10.1 - Основное окно Turbo Pascal
Для создания нового документа необходимо из меню File
выбрать пункт New
. В появившемся окне можно начинать вводить текст программы. Turbo Pascal помогает нам избежать некоторых простых ошибок. Зарезервированные слова выделяются ярким белым цветом, комментарии – серым, остальные слова – желтым. Таким образом, если ваша переменная стала вдруг белого цвета, то это означает, что вы пытаетесь использовать недопустимое имя переменной, если цвет текста вдруг стал приятно-серый, значит вы пропустили закрывающую фигурную скобку.
На рис 10.2 отмечены основные элементы окна.
Рис. 10.2 - Основные элементы окна
1. Строка заголовка (указывается заголовок программы).
2. Строка меню (все доступные команды можно найти в меню).
3. Название текущего файла.
4. Курсор.
5. Положение курсора (номер строки/номер позиции).
6. Полосы прокрутки.
7. Звездочка, сигнализирующая о том, что данная версия программы не была сохранена. Перед выполнением программы желательно сохранить (клавиша F
2
), так как если в процессе выполнения программа "зависнет", то все несохраненные изменения пропадут.
8. Строка состояния (в ней перечислены основные команды).
Рекомендации по написанию текстов программ
При написании текстов программы целесообразно пользоваться системой отступов от левого края для того, чтобы было проще понимать ее структуру. Система отступов предполагает написание отдельных строк программы с различными отступами от начала строки. При этом, чем глубже вложенность в теле программы тех или иных операторов, тем больший отступ они имеют, а операторы одного уровня вложенности пишутся с одинаковыми отступами. Так, заголовок программы, названия разделов, тело программы записываются с минимальным или нулевым отступом. Содержимое разделов программы, содержимое тела программы пишутся с отступом (обычно отступы делаются в две позиции) относительно строк объявлений и операторных скобок (составного оператора begin .. end). Встроенные части структурированных операторов также пишутся с отступом относительно начала этих операторов. Особо важно правильно оформлять составные операторы, заключенные в операторные скобки begin и end. Эти два слова следует писать одно под другим с одинаковым отступом, а сами операторы этого составного оператора - между ними с отступом по отношению к этим словам. В этом случае наглядно видны начало и конец такого оператора и, что особенно важно, легче избежать непарных операторных скобок составного оператора - ошибки, которая часто встречается при написании программ. Да и определить, какая из открывающих скобок не дополнена закрывающей скобкой, в этом случае будет проще. По этой же причине можно рекомендовать при написании составных операторов сначала сразу же написать его открывающую и закрывающую скобки (begin и end), а затем уже между ними его операторы с дополнительным отступом.
После того, как текст программы набран, необходимо сохранить изменения (клавиша F
2
). Если сохранение происходит впервые, то появится окно, показанное на рис. 3, в котором необходимо ввести имя файла и указать папку для сохранения.
Рис 10. 3 - Сохранение текста программы
Теперь можно приступать к компиляции программы. Для этого нужно нажать клавишу F9 и подождать некоторое время. На простых коротких программах это время практически незаметно, тогда как время компиляции сложных программ может составлять несколько минут. После завершения компиляции выдается сообщение о результатах (рис. 4). Если в программе ошибок нет, то можно переходить к ее запуску. Для этого нажимаем сочетание клавиш Ctrl
+
F
9
. В противном случае выполнение компиляции программы приостанавливается на строке, в которой, по мнению компилятора, содержится ошибка. Программисту необходимо исправить ошибку и попытаться откомпилировать программу заново. Обратите внимание, что не всегда ошибка находится в строке, указанной компилятором. Иногда нужно просмотреть весь текст программы, чтобы найти ошибку.
Рис. 10.4 - Результаты компиляции
Приведем примеры наиболее часто встречаемых ошибок, обнаружив которые компилятор выдает следующие сообщения.
"
Unknown
identifier
" –
(неизвестный идентификатор) встретилась переменная, константа или функция, которая не описана в разделе описаний.
"
Type
mismatch
"
- (неверный тип) переменной присваивается значение другого типа. Например, целочисленной переменной присваивается дробное или символьное значение.
"
Duplicate
identifier
" –
(повторный идентификатор) повторное использование одного и того же идентификатора для описания переменных, констант, типов или функций внутри одного блока.
"
Identifier
expected
"
- (ожидается идентификатор) такая ошибка возникает при попытке использования служебного слова в качестве имени переменной, функции, процедуры и т.д., в этом случае следует заменить служебное слово на идентификатор. Например:
Var mod:integer;
или
function Case();
"
Constant
out
of
range
"
– (выход за пределы диапазона) переменной присваивается значение выходящее за пределы диапазона допустимых значений для данной переменной. Допустимый диапазон определяется типом переменной. Например, если переменной s, имеющей тип byte, попытаться присвоить значение 500, то компилятор выведет указанное сообщение.
"
Boolean
expression
expected
"
- (ожидается выражение булевского типа) данная ошибка часто встречается при использовании условного оператора, в котором после if должно стоять логическое выражение. Например, запись if
a:=8 then
…– неверна, if
a=8 then
…- верна.
В процессе выполнения программы пользователь может вводить в компьютер какие-либо данные, на экран могут выводиться некоторые результаты. Однако, после завершения выполнения программы на экране вновь появляется текст программы. Если нам нужно посмотреть ход выполнения программы (то, что отображалось на экране во время выполнения), то нужно нажать сочетание клавиш Alt
+
F
5
. Повторное нажатие клавиш Alt
+
F
5
приведет вновь к переходу в программу Turbo Pascal.
Для выхода из программы Turbo Pascal нужно нажать сочетание клавиш Alt
+
X
. Если вы не сохранили последние изменения, то вам будет предложено это сделать (рис. 10.5).
Рис. 10.5 - Предложение на сохранение
Для того чтобы в следующий раз продолжить работу над программой, вам необходимо, открыв Turbo Pascal, открыть свой файл. Для этого в меню File выбираем пункт Open. Появится окно открытия файла, изображенное на рис. 10.6.
Рис. 10.6 - Открытие файла
10.2 Отладчик
Ошибки, возникающие при компиляции, довольно легко обнаружить. Гораздо сложнее дело обстоит с ошибками, возникающими в процессе выполнения программы. Программисту нужно построчно, шаг за шагом выполнять программу, при этом наблюдать за значением некоторых переменных.
Запустить отладчик достаточно просто. Для этого достаточно нажать клавишу F
7
или F
8
. Отличие этих двух клавиш заключается в том, что при нажатии F
8
полностью будет выполнена строка, отмеченная на экране. Действие F
7
часто аналогично F
8
, но если очередная отмеченная строка является именем подпрограммы (процедуры или функции), то, нажав клавишу F
7
, мы войдем внутрь этой подпрограммы, тогда как если бы мы нажали F
8
, то данная подпрограмма выполнилась бы полностью.
Если нам необходимо проверить работу какого-то участка программы, то в этом случае можно установить курсор на начало этого блока и нажать клавишу F
4
. Программа выполнится ровно до того места, где вы поставили курсор. Далее можно выполнять отладку программы, как это было описано выше.
Как было сказано, в Turbo Pascal имеется возможность просматривать текущие значения переменных. Для этого нужно нажать сочетание клавиш Ctrl
+
F
7
. В появившемся диалоговом окне (рис. 10.7) вводится имя требуемой переменной.
Рис. 10.7 - Ввод переменных, подлежащих наблюдению
После того, как введено имя переменной, появляется окно (рис 10.8), в котором указывается текущее значение наблюдаемых переменных. После каждого шага выполнения программы происходит пересчет значений всех переменных.
Рис. 10.8 - Просмотр значений переменных
Программист может менять размер и расположение окон во время работы. Изменить размер окна можно с помощью мыши. Для этого наведите курсор на правый нижний угол окна, нажмите левую кнопку мыши и, не отпуская кнопки, измените размер по горизонтали и вертикали. Если навести курсор на верхнюю полосу окна, то аналогично можно изменять положение окна. Пример работы отладчика и расположения окон показан на рис. 10.9.
В завершения отметим, что после компиляции программы на диске создается исполняемый файл – файл с тем же именем, что и файл, содержащий исходный текст, имеющий расширение *.
exe
.
Посмотреть выполнение файла, содержащего текст программы, написанный на языке Pascal (с расширением .
pas
) можно только откомпилировав его, например, в программе Turbo Pascal. Исполняемые файлы можно запускать без какой-либо дополнительной программы.
Рис. 10.9 - Пример работы отладчика
Методические указания по выполнению контрольной работы №2
Для выполнения письменной контрольной потребуются знания о работе с циклами, массивами, строками, записями и файлами, умение алгоритмизировать и использовать подпрограммы. Каждое задание содержит несколько подзадач, которые должны быть выполнены в комплексе. В результате выполнения контрольной работы должно быть получено несколько файлов.
Первый файл, с программой создания файла, содержащего информацию о чем-либо, должен называться f1.pas. Для представления информации используйте записи. Созданный файл должен содержать не менее 10-ти записей. Информация, записываемая в файл, вводится с клавиатуры.
Второй файл – созданный файл, с расширениями .dat или .txt, если имя файла не указано в задании, то оно должно запрашиваться у пользователя.
Третий файл f2.pas – файл с основной программой. В программе выполняется считывание информации из файла и ее обработка в соответствии с заданием. Если требуется упорядочить информацию в каком-либо порядке, используйте сортировку, оформив ее в виде отдельной процедуры. При упорядочивании в алфавитном порядке, когда сортировка ведется по строкам, применяйте операции сравнения строк. Если в задании требуется определить самый большой, самый маленький, самый старый и т.д. элемент, то задача сводится к поиску максимального или минимального элемента. Необходимо оформить поиск в виде функции, результатом работы которой будет номер искомого элемента. В программе должны присутствовать подробные комментарии об используемых переменных и выполняемых действиях.
Четвертый файл – выходной текстовый файл, содержит итоговую требуемую информацию. В некоторых заданиях требуется получить несколько выходных файлов.
Для проверки контрольной работы высылаются все перечисленные файлы.
Варианты контрольной работы №2
1. Создать файл, содержащий информацию о десяти студентах (Ф.И.О., три оценки, номер группы). Переписать сведения из этого файла в текстовый файл так, чтобы студенты перечислялись в соответствии с порядком возрастания среднего балла.
2. Создать текстовый файл bibliot.txt, который содержит сведения о 10 книгах (автор, название, год издания). Найти и переписать в отдельный файл в алфавитном порядке книги, издаваемые с 1960г. Выяснить, имеется ли книга с названием "Информатика", если имеется, то вывести фамилию автора и год издания.
3. Создать не текстовый файл, который содержит информацию о телефонах сотрудников учреждения (фамилия, инициалы и номер телефона). Требуется:
1) найти номер телефона сотрудника по его фамилии;
2) переписать в алфавитном порядке в текстовый файл информацию о сотрудниках, у которых первые цифры телефона 41.
4. Создать не текстовый файл, с информацией о днях рождения сотрудников (фамилия; дата рождения: год, месяц, число). Вводится произвольная дата. Переписать в текстовый файл фамилии всех сотрудников, у которых день рождения в этом месяце. Фамилии упорядочить в возрастающем порядке. Имя файла построить следующим образом: BirthNN.txt, где NN – номер месяца. Вывести на экран информацию о ближайшем дне рождения.
5. Создать не текстовый файл Play.Dat, который содержит сведения об игрушках (наименование, цена, возрастные границы (например, от 3-х до 10 лет)). Вывести в текстовый файл названия игрушек, упорядоченных в порядке возрастания цены, цена которых не превышает 200 рублей и предназначенных для детей 5 лет. Вывести на экран цену самого дорогого "конструктора".
6. Создать текстовый файл fonotek.txt, содержащий сведения об альбомах различных групп (название группы, название альбома, год выпуска, стиль). Удалить из файла все альбомы в стиле pop и techno. Переписать в другой файл информацию об альбомах в порядке убывания года выпуска.
7. Создать не текстовый файл, содержащий сведения о студентах (фамилия имя отчество, курс). Создать пять текстовых файлов, в каждый из которых записать в алфавитном порядке Ф.И.О. студентов отдельного курса.
8. Создать не текстовый файл, содержащий сведения о процессорах (модель, тактовая частота, стоимость). Вывести в текстовый файл информацию о процессорах, стоимость которых не превышает суммы, вводимой пользователем, упорядочив их по возрастанию частоты. Вывести на экран модель и тактовую частоту наилучшего из подходящих по стоимости процессоров.
9. Создать два не текстовых файла, содержащих сведения об успеваемости учеников (фамилия, инициалы, три оценки). Упорядочить сведения в алфавитном порядке. Перезаписать данные из этих файлов в текстовый файл, также упорядоченный в алфавитном порядке. Вывести на экран фамилии трех лучших учеников.
10. Создать не текстовый файл, в котором записаны сведения о пациентах поликлиники (Фамилия, год рождения, номер страхового полиса, дата последнего посещения: число, месяц). Вывести в текстовый файл фамилии и номера полиса пациентов, посетивших поликлинику в текущем месяце. Месяц вводится с клавиатуры пользователем. Вывести в другой файл, информацию о пациентах в алфавитном порядке. Вывести на экран фамилии самого молодого и самого старого пациентов.
11. Создать не текстовый файл Video.Dat, в котором хранятся данные о фильмах (название фильма, киностудия, режиссер, год выпуска). Переписать в текстовый файл информацию о фильмах упорядоченную по году выпуска. Переписать в отдельный файл режиссеров и названия фильмов, снимавшихся на одной киностудии. Вывести на экран информацию о фильмах, снятых до 1999г.
12. Создать не текстовый файл Book.Dat, в котором хранятся данные о книгах (название книги, автор, число страниц, год издания). Переписать в текстовый файл информацию о книгах, упорядоченную в алфавитном порядке по авторам. Переписать в отдельный файл авторов и названия книг, изданных после 2000г. Вывести на экран название самой толстой книги.
13. Создать не текстовый файл fruit.Dat, содержащий информацию о поставках фруктов в магазин (наименование, цена, объем поставки (количество килограмм)). Переписать в текстовый файл информацию о поставках, упорядоченную в порядке возрастания объемов. Вывести на экран название самых дешевых фруктов. Вывести на экран среднюю стоимость килограмма любых фруктов.
14. Создать не текстовый файл news.Dat, содержащий информацию о выпускаемых газетах (название, тираж, дата выпуска (число, месяц)). Переписать в текстовый файл информацию о газетах, упорядоченную в алфавитном порядке, тираж которых превышает 10000. Вывести на экран название газеты, имеющей наибольший тираж. Ввести текущую дату, вывести на экран название самой свежей газеты.
15. Создать не текстовый файл animal.Dat, содержащий информацию о животных (название, вид (дикое или домашнее), численность). Переписать в текстовый файл информацию о диких животных, упорядоченную в алфавитном порядке. Вывести на экран названия животных, численность которых меньше 1000. Определите каких больше животных, диких или домашних, содержится в вашем файле.
16. Создать не текстовый файл car.Dat, содержащий информацию о машинах (марка, год выпуска, цвет, номер). Переписать в текстовый файл информацию о машинах черного цвета, упорядоченную в порядке убывания года выпуска. Вывести на экран марки машин, номера которых начинаются на букву М.
17. Создать не текстовый файл berd.Dat, содержащий информацию о птицах (название, регион обитания, максимальный размер). Переписать в текстовый файл информацию о сибирских птицах, упорядоченную в алфавитном порядке. Вывести на экран названия, самой маленькой и самой большой птицы.
18. Создать не текстовый файл bank.Dat, содержащий информацию о клиентах банка (фамилия, номер счета (строка), сумма денег на счету). Переписать в текстовый файл информацию о клиентах, упорядоченную в алфавитном порядке. Ввести номер счета и вывести на экран фамилию владельца данного счета. Вывести на экран фамилии клиентов сумма денег на счету которых превышает 100000.
19. Создать не текстовый файл bank.Dat, содержащий информацию о клиентах банка (фамилия, номер счета (строка), сумма денег на счету). Переписать в текстовый файл информацию о клиентах, упорядоченную в алфавитном порядке. Ввести номер счета и вывести на экран фамилию владельца данного счета. Вывести на экран фамилии клиентов, сумма денег на счету которых, превышает 100000.
20. Создать не текстовый файл sport.Dat, содержащий информацию о спортсменах, участвовавших в олимпиаде (фамилия, страна, вид спорта, занятое место). Переписать в текстовый файл информацию о российских спортсменах, упорядоченную в порядке убывания занятых мест. Ввести название страны и вывести на экран фамилии спортсменов из этой страны. Вывести в отдельный файл названия стран и фамилии спортсменов занявших призовые места.
21. Создать не текстовый файл family.dat, содержащий информацию о родственниках (фамилия имя, возраст, кем приходится (отец, брат и т.д.)). Введите свой возраст. Перепишите в текстовый файл в алфавитном порядке информацию о родственниках, которые старше вас. Выведите на экран фамилию и имя самой младшей сестры.
22. Создать не текстовый файл picture.dat, содержащий информацию о картинах (название, автор, время написания (год)). Перепишите в текстовый файл в информацию о картинах написанных до 1900 года, в алфавитном порядке по авторам. Введите название какой-либо картины, и если картина с таким названием имеется, то выведите ее автора. Выведите на экран название и автора самой старой картины.
Литература
1. Абрамов В.Г. и др. Введение в язык Паскаль. - М., "Наука", 1988.
2. Абрамов С.А. Зима Е.В. Начала программирования на языке Паскаль. - "Наука", 1987.
3. Боон К. Паскаль для всех / Пер. с гол. - М., "Мир",1982.
4. Белецкий Я. TURBO-PASCAL с графикой для персональных компьютеров - М.,"Машиностроение",1991.
5. Вирт Н. Алгоритмы и структуры данных/ Пер. с англ. – 2-е изд. – СПб.:
6. Невский Диалект, 2001. – 352 с.
7. Горогоно П. Программирование на языке Паскаль. - М., "Мир", 1982.
8. Джонс Ж., Харроу К. Решение задач в системе ТУРБО ПАСКАЛЬ.- М., "Финансы и статистика", 1991.
9. Йодан Э. Структурное программирование и конструирование программ. - М., "Мир", 1989.
10. Кнут Д.Э. Искусство программирования. – М.-Спб.-К.: Вильямс, 2000.
11. Перминов О.Н. Язык программирования Паскаль. - М., "Радио и связь", 1983.
12. Семашко Г.Л., Салтыков А.И. Программирование на языке Паскаль. - М., "Наука" , 1988.
13. Фигурнов А.Ф. TURBO PASCAL 6.0 1992.