Лекция 1. Структура программы на языке Turbo Pascal

Лекция 1. Структура программы на языке Turbo Pascal

 

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

b:=5; a:=sib(b);

или b:=5; a:=sib(b);

или b        :=5; a:=sib( b    );

Все эти записи эквивалентны!

 

Приведём простейший пример программы, единственная цель которой – вывести на экран какое-нибудь приветствие:

program Hello;

begin

writeln('Hello, world!');

readln;

end.

Первая строка ничего не делает, она просто содержит название программы. Затем, после слова begin начинаются собственно действия. В нашей программе их два: первое – это вывод строчки «Hello, world» на экран, а второе – ожидание нажатия клавиши «Enter», оно нужно для того, чтобы можно было увидеть результат программы, а затем уже нажать «Enter» и вернуться в Турбо-Паскаль. И, наконец, слово end с точкой в последней строке говорит о том, что программа закончилась. Действия, из которых состоит программа, называются операторами, они отделяются друг от друга точкой с запятой.

А теперь приведём пример, в котором программа уже не «глухая», то есть может запрашивать какие-либо данные у пользователя. Пусть требуется спросить у пользователя два числа, после этого вывести на экран их произведение:

program AxB;

var a,b: integer;

begin

writeln('Введите a и b');

readln(a,b);

writeln('Произведение равно ',a*b);

readln;

end;

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

О том, что делает первый оператор, нам известно: он выводит на экран строчку 'Введите a и b'. При выполнении второго оператора программа будет ждать, пока пользователь не введет число с клавиатуры и не нажмёт «Enter»; это число программа запишет в переменную a, затем то же самое делается для переменной b. Третьим оператором выводим на экран сначала надпись «Произведение равно», а потом значение выражения a×b («*» – знак умножения). Четвёртый оператор пояснений не требует.

А теперь рассмотрим структуру программы в общем виде. Любая программа на Турбо-Паскале состоит из трех блоков: блока объявлений, блока описания процедур и функций и блока основной программы. Ниже эти блоки расписаны более подробно. (на слайде)

Блок объявлений:

program... (название программы)

uses... (используемые программой внешние модули)

const... (объявления констант)

type... (объявления типов)

var... (объявления переменных)

Блок описания процедур и функций:

procedure (function)

Begin

...

end;

...

Блок основной программы:

Begin

... (операторы основной программы)...

end;

 

Рассмотрим наиболее важные части вышеописанных блоков. Под заголовком программы понимается имя, помогающее определить её назначение. Имя, или идентификатор, строится по следующим правилам: оно может начинаться с большой или малой буквы латинского алфавита или знака «_», далее могут следовать буквы, цифры или знак «_»; внутри идентификатора не может стоять пробел. После имени программы следует поставить «;», этот знак служит в Паскале для разделения последовательных инструкций. Заметим, что имя программы может не совпадать с именем соответствующего файла на диске.

После слова const помещаются описания постоянных, которые будут использованы в программе, например:

 

const Zero = 0;

pi = 3.1415926;

my_const = -1.5;

Hello = 'Привет!';

 

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

Название типа	Возможные значения	Примеры значений
integer	целые: -32768... 32767	12, -10000
real	действительные (по модулю): 2,9x10-39... 1,7x1038	-9.81, 6.02e-23
string[n]	строка до n символов длиной, если [n] не указано, то до 255	‘abcde’, ‘привет’
char	одиночный символ	‘F’, ‘!’, ’_’,’ю’

 

Объявления переменных записываются в следующей форме: var <переменная>: <тип>;

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

Примеры объявления:

var Number: integer;

d,l: real;

Name: string [20];

Line: string;

Key1,Key2: char;

 

Блок основной программы. Здесь, между словами begin и end. располагаются команды (точнее, операторы), которые будут выполняться один за другим при запуске программы. Рассмотрим простейшие типы операторов на следующем примере:

 

program First;

const a2 = 3;

a1 = -2;

a0 = 5;

var x,f: real;

 

Begin

write(‘Введите значение х ’);

readln(x);

f:= a2*x*x+a1*x+a0;

writeln(‘Значение квадратного трехчлена: ’,f);

end.

 

Первая строка исполняемой (основной) части программы выводит на экран надпись «Введите значение х», для этого используется процедура write написанная разработчиками Турбо Паскаля, то есть набор команд, невидимый для нас, но существующий реально в недрах системы Турбо Паскаль. В качестве параметра этой процедуры используется наша строчка. Параметры всегда записываются в круглых скобках, апострофы означают, что параметр имеет строковый тип. Итак, в первой строке мы видим так называемый оператор вызова процедуры. Каждый оператор отделяется от следующего знаком «;». Во второй строке вызывается процедура ввода readln(x), которая ждет, пока пользователь наберет значение x с клавиатуры и нажмет клавишу «Enter», а затем переводит курсор на следующую строку (ln ó Line – строка). В третьей строке вычисляется значение трехчлена и записывается в переменную f; этот оператор называется оператором присваивания, и обозначается символом ":=". В последней строке на экран выводится строка «Значение квадратного трехчлена:» и значение переменной f. Несложно заметить, что здесь процедуре writeln передается уже не один, а два параметра, причем они могут иметь разные типы. Вообще, процедуры ввода и вывода (т.е. write, writeln, read, readln) могут иметь любое число параметров различных типов, параметрами могут являться переменные, литералы (т.е. непосредственно записанные числа, строки; в нашем примере дважды были использованы строковые литералы), а также выражения. Используя выражение при выводе, можно заменить две последние строчки нашей программы одной:

writeln('Значение квадратного трехчлена: ', a2*x*x+a1*x+a0);

В арифметических выражениях на Паскале используются следующие знаки для обозначения операций: +, -, *, /. Для определения порядка действий используются круглые скобки согласно общепризнанным математическим правилам.

Замечание об именах. Для обозначения переменных запрещается использование ряда слов, называемых зарезервированными, они играют в языке особую роль. Нам уже встречался ряд зарезервированных слов: program, begin, end, string, const, var, и т.п.

 

Begin

write('Введите два числа:');

readln(a,b);

writeln('Сумма a и b равна ',a+b);

readln;

end.

 

Оператор if.

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

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

Под оператором понимается либо одиночный оператор (например, присваивания, вызова процедуры), либо т.н. составной оператор, состоящий из нескольких простых операторов, помещённых между словами begin и end. Важно заметить, что перед else не ставится точка с запятой. Часть else может и отсутствовать.

Пример 1: пусть требуется найти число m=max(a,b). Этой задаче соответствует следующий фрагмент программы на Паскале:

if a>b then m:=a else m:=b;

Пример 2: (без else) пусть дано целое число i. Требуется оставить его без изменения, если оно делится на 2, и вычесть из него 1, если это не так.

var i: integer;

.......

if i mod 2 = 1 then i:=i-1; {else - ничего не делать}

Примечание: в примере использована операция нахождения остатка от деления (mod), для нахождения неполного частного в Турбо-Паскале используется div.

Пример 3: (с использованием составного оператора). Пусть даны две переменные типа real. Требуется поменять местами значения этих переменных, если a1>a2.

var a1,a2,buf:real;

.........

if a1>a2 then begin

buf:=a1;

a1:=a2;

a2:=buf;             

end;

 

Следующий пример использует вложенные операторы if.

Пример 4: Поиск корней квадратного уравнения.

program SqEquation;

var a,b,c,d: real;

Begin

writeln;

write('Введите коэффициенты a,b,c квадратного уравнения: ');

readln(a,b,c);

d:=sqr(b)-4*a*c;

if d>=0 then

if d=0 then writeln('Единственный корень: x=',-b/(2*a):8:3)

   else writeln('Два корня: x1=',(-b+sqrt(d))/(2*a):8:3,

                          ', x2=',(-b-sqrt(d))/(2*a):8:3)

else {d<0} writeln('Корней нет');

readln;

end.

Чтобы не запутаться в структуре этой программы, следует помнить такое правило: else всегда относится к последнему оператору if. Если же в программе требуется, чтобы else относилось к одному из предыдущих if, то придется воспользоваться составным оператором:

Пример 5: пользователь вводит натуральное число, задача программы — поставить слово «ученик» в нужную форму в сочетании с числительным (например: 1 ученик, 3 ученика, 9 учеников и т.п.)

Begin

write('Число учеников (1..20) --> '); readln(n);

write(n, ' ученик');

if n<5 then begin

if n>1 then writeln('а');

   end

Else

writeln('ов');

  readln;

end.

В этом примере пришлось использовать составной оператор (begin... end;) для того чтобы часть else относилась не к оператору if n>1, а к if n<5.

Оператор выбора (case)

Кроме оператора условного выполнения и циклов в Турбо Паскале имеется ещё одна управляющая конструкция, одно из названий которой — оператор выбора. На самом деле это усложнённый оператор if, он позволяет программе выполняться не двумя способами, в зависимости от выполнения условия, а несколькими, в зависимости от значения некоторого выражения. В общем виде этот оператор выглядит так:

case Выражение of

Вариант1: Оператор1;

Вариант2: Оператор2;

...

ВариантN: ОператорN;

[ else ОператорN1;]

end;

(Пояснение: квадратные скобки означают то, что часть else может отсутствовать).

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

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

2. Интервал, например: 1..5, 'a'..'z'.

3. Список значений или интервалов, например: 1,3,5..8,10,12.

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

Рассмотрим пример. Пусть пользователь вводит целое число от 1 до 10, программа должна приписать к нему слово «ученик» с необходимым окончанием (нулевое, «а» или «ов»).

 

program SchoolChildren;

var n: integer;

Begin

write('Число учеников --> '); readln(n);

write(n,' ученик');

case n of

2..4: write('а');

5..10: write('ов');

end;

readln;

end.

 

Можно также усовершенствовать программу для произвольного натурального n:

 

write(n,' ученик');

case n mod 100 of

11..19: write('ов');

else case n mod 10 of

2..4: write('а');

0,5..9: write('ов');

end;

end;

 

Begin

sum:=0; i:=0;

Repeat

i:=i+1;

sum:=sum+i;

until i=100;

writeln('Сумма равна: ',sum);

readln;

end.

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

Цикл с предусловием (While)

Этот цикл записывается так: while <условие> do <оператор>. (Пока условие истинно, выполнять оператор). Суть в следующем: пока условие истинно, выполняется оператор (в этом случае оператор может не выполниться ни разу, т.к. условие проверяется до выполнения). Под оператором здесь понимается либо простой, либо составной оператор (т.е. несколько операторов, заключёных в begin... end).

Рассмотрим тот же пример, выполненный с помощью while:

var i,sum: integer;

Begin

sum:=0; i:=0;

while i<100 do begin

i:=i+1;

sum:=sum+i;

end;

writeln('Сумма равна: ',sum);

readln;

end.

Цикл со счетчиком (For)

Записывается так: for <переменная>:=<нач> to <кон> do <оператор>. Вместо to возможно слово downto. Рассмотрим такой пример: требуется вывести на экран таблицу квадратов натуральных чисел от 2 до 20.

var i: integer;

begin for i:=2 to 20 do writeln(i,' ',sqr(i)); end.

При выполнении цикла происходит следующее: переменной i присваивается начальное значение (2), затем выполняется оператор (простой или составной), после этого к i прибавляется 1, и проверяется, не стало ли значение i равно конечному (20). Если нет, то вновь выполняется оператор, добавляется 1, и т. д. В случае, когда вместо to используется downto, все происходит наоборот: единица не прибавляется, а вычитается. Например, следующий цикл выведет ту же таблицу, но в обратном порядке:

for i:=20 downto 2 do writeln(i,' ',sqr(i));

В завершение запишем программу о подсчете суммы чисел от 1 до 100 с помощью for:

var i, sum: integer;

Begin

sum:=0;

for i:=1 to 100 do sum:=sum+i;

  writeln(sum);

end.

 

Пример

program summ; {Пример: Сортировка массива по возрастанию}

uses crt;

var a:array[1..100] of integer;

s,j,n,i:integer;

Begin

clrscr;

write('vvedite chislo elementov: ');

read(n);

for i:=1 to n do

Begin

  write('a[i]: ');

   read(a[i]);

end;

      

for i:=1 to n-1 do  begin for j:=i+1 to n do begin   if a[i]>a[j] then    begin     s:=a[i];     a[i]:=a[j];     a[j]:=s;   end; end;  end; for i:=1 to n do write(a[i]); end.

a(5) = (3, 7, 2, 5, 8), n = 5 Циклы по i= 1..4, j= 2..5 I ит.: i=1, j=2                          II ит.: i=1, j=3 s=3, a(1)=2, a(3)=3     III ит.: i=1, j=4                                               IV ит.: i=1, j=5                                   V ит.: i=2, j=3 s=7, a(2)=3, a(3)=7     …

 

 

Символьный тип

Тип данных, переменные которого хранят ровно один символ (букву, цифру, знак препинания и т.п.) называется символьным, а в Паскале — char. Объявить переменную такого типа можно так: var ch: char;. Для того чтобы положить в эту переменную символ, нужно использовать оператор присваивания, а символ записывать в апострофах, например: ch:='R';. Для символьных переменных возможно также использование процедуры readln, например:

write(‘Выйти из игры? (Д а/ Н ет)’); readln(ch);

if ch=’Д’ then...{выходить}...

else...{продолжать}...;

 

Символьные переменные в памяти компьютера хранятся в виде числовых кодов, иначе говоря, у каждого символа есть порядковый номер. К примеру, код пробела равен 32, код ‘A’ — 65, ‘B’ — 66, ‘C’ — 67, код символа ‘1’ — 48, ‘2’ — 49, ‘.’ — 46 и т. п. Некоторые символы (с кодами, меньшими 32) являются управляющими, при выводе таких символов на экран происходит какое либо действие, например, символ с кодом 10 переносит курсор на новую строку, с кодом 7 — вызывает звуковой сигнал, с кодом 8 — сдвигает курсор на одну позицию влево.

Под хранение символа выделяется 1 байт (байт состоит из 8 бит, а бит может принимать значения 0 или 1), поэтому всего можно закодировать 2⁸=256 различных символов. Кодировка символов, которая используется Турбо-Паскале, называется ASCII (American Standard Code for Information Interchange — американский стандартный код для обмена информацией).

Для того чтобы получить в программе код символа нужно использовать функцию chr, например:

var i: byte; {число, занимающее 1 байт, значения — от 0 до 255}

ch: char;

...

readln(i); writeln('символ с кодом ',i,' — это ',chr(i));

Если в качестве кода используется конкретное число, а не выражение и не переменная, то можно использовать символ «#», скажем так: ch:=#7;. Для того перехода от кода к символу используется функция ord (от слова ordinal — порядковый). Имеющиеся знания позволяют нам написать программу, которая выдаёт на экран таблицу с кодами символов:

program ASCII;

var ch: char;

Begin

for ch:=#32 to #255 do write(ord(ch),'—>',ch,' ');

readln;

End.

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

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

1. succ (от succeedent — последующий), она выдаёт символ со следующим кодом.

2. pred (от predecessor — предшественник), выдаёт символ с предыдущим кодом.

Если попытаться в программе получить succ(#255) или pred(#0), то возникнет ошибка. Пользуясь этими функциями можно переписать предыдущую программу и по-другому:

...

ch:=#32;

while ch<>#255 do begin

write(ord(ch),'—>',ch,' ');

ch:=succ(ch);

end;

...

 

Сравнение символов. Также как и числа, символы можно сравнивать на =, <>, <, >, <=, >=. В этом случае Паскаль сравнивает не сами символы, а их коды. Таблица ASCII составлена таким образом, что коды букв (латинских и большинства русских) возрастают при движении в алфавитном порядке, а коды цифр расположены по порядку: ord(‘0’)=48, ord(‘1’)=49,... ord(‘9’)=57. Сравнения символов можно использовать везде, где требуются логические выражения: в операторе if, в циклах и т.п.

Строковый тип

Для хранения строк (то есть последовательностей из символов) в Турбо-Паскале имеется тип string. Значениями строковых переменных могут быть последовательности различной длины (от нуля и более, длине 0 соответствует пустая строка). Объявить строковую переменную можно двумя способами: либо var s: string; (максимальная длина строки — 255 символов), либо var s: string[n]; (максимальная длина — n символов, n — константа или конкретное число).

Для того чтобы положить значение в строковую переменную используются те же приёмы, что и при работе с символами. В случае присваивания конкретной строки, это строка должна записываться в апострофах (s:='Hello, world!'). Приведём простейший пример со строками: программа спрашивает имя у пользователя, а затем приветствует его:

program Hello;

var s: string;

Begin

write('Как Вас зовут: ');

readln(s);

write('Привет, ',s,'!');

readln;

end.

 

Хранение строк. В памяти компьютера строка хранится в виде последовательности из символьных переменных, у них нет индивидуальных имён, но есть номера, начинающиеся с 1). Перед первым символом строки имеется ещё и нулевой, в котором хранится символ с кодом, равным длине строки. Нам абсолютно безразлично, какие символы хранятся в байтах, находящихся за пределами конца строки. Рассмотрим пример. Пусть строка s объявлена как string[9], тогда после присваивания s:=’Привет’; она будет хранится в следующем виде:

Номер байта	0	1	2	3	4	5	6	7	8	9
Содержимое	#6	‘П’	‘р’	‘и’	‘в’	‘е’	‘т’	‘ю’	‘s’	‘%’

Для того чтобы в программе получить доступ к n-му символу строки используется запись s[n]. Если поменять значение s[0] то это отразится на длине строки. В следующем примере из строки 'Привет' мы сделаем 'Привет!': s[0]:=#7; s[7]:='!';.

Сравнение строк. Строки сравниваются последовательно, по символам. Сравниваются первые символы строк, если они равны — то вторые, и т. д. Если на каком-то этапе появилось различие в символах, то меньшей будет та строка, в которой меньший символ. Если строки не различались, а затем одна из них закончилась, то она и считается меньшей. Примеры: 'ананас'<'кокос', 'свинья'>'свинина', ''<'A', 'hell'<'hello'.

Склеивание (конкатенация) строк. К строкам можно применять операцию «+», при этом результатом будет строка, состоящая из последовательно записанных «слагаемых». Пример: после действия s:= 'abc'+'def'+'ghi'; переменная s будет содержать ‘abcdefghi’.

Процедуры и функции для работы со строками. Наиболее часто употребляется функция length(s: string): integer (после двоеточия записан тип значения, возвращаемого функцией, в нашем случае — целое число). Эта функция возвращает длину строки s.

Другие процедуры и функции приведены в таблице:

Процедура или функция	Назначение	Пример
функция Copy(s: string; start: integer; len: integer): string	Возвращает вырезку из строковой переменной s, начиная с символа с номером start, длина которой len	s:=’Бестолковый’; s1:=Copy(s,4,4); { в s1 станет ‘ толк ’}
функция Pos(s1: string; s: string): byte	Ищет подстроку s1 в строке s. Если находит, то возвращает номер символа, с которого начинается первое вхождение s1 в s; если s1 не входит в s, то функция возвращает 0	n:=pos(‘министр’,        ‘администратор’); {=3} n:=pos(‘abc’,   ‘stuvwxyz’); {=0}
процедура Insert(s1: string; s: string; start: integer)	Вставляет строку s1 в строковую переменную s начиная с символа с номером start.	S:=‘кот’; insert(‘мпо’,s,3); { в s станет ‘ компот ’}
процедура Delete(s: string; start: integer; len: integer)	Удаляет из строковой переменной s фрагмент, начинающийся с символа с номером start и длиной len	s:= ‘треугольник’; delete(s,4,7); {в s останется ‘трек’}

 

Перечисляемый тип

 

Предположим, что нам требуется переменная для хранения дня недели. В этом случае можно воспользоваться целым типом (например byte) и хранить дни недели в виде чисел 1, 2,... 7, но это будет не очень наглядно. Турбо Паскаль предоставляет более удобный вариант, а именно создание перечислимого типа, например, такого:

type Days = (Mon, Tue, Wed, Thu, Fri, Sat, Sun);

После этого можно завести переменную этого типа (var day: Days;) и использовать её. Ниже приведены примеры использования:

day:=Wed;

...

if day>Fri then writeln('Сегодня выходной');

...

if day=Mon then writeln('Началась рабочая неделя');

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

Для переменных перечисляемых типов возможно применение функций succ и pred, например, succ(Wed) дает Thu, Pred(Sun) дает Sat. Если попытаться написать Pred(Mon) или Succ(Sun), то уже на этапе проверки программы компилятором произойдет ошибка.

Хранение значений перечисляемого типа устроено внутри довольно просто: хранятся целые числа от 0 до n, в нашем случае n=6. Существует функция Ord, которая позволяет получить то число, в виде которого хранится какое-либо значение перечисляемого типа, например Ord(Wed) дает 2. При необходимости можно получить значение перечисляемого типа по его численному представлению, например, Days(1) есть Tue. После всего сказанного можно заметить, что при сравнении величин перечисляемого типа в действительности сравниваются их порядковые номера (Ord).

 

Пример использования перечисляемых типов:

Пусть корабль может двигаться только по четырем направлениям: на север, на запад, на юг и на восток, то есть текущее направление движения определяется переменной типа Directions = (North, West, South, East);. Этому кораблю можно подавать приказы следующих типов: вперёд, назад, влево, вправо, то есть любой приказ задать переменной типа Orders = (Ahead, Back, Left, Right);. Пусть корабль двигался по направлению d1, после чего ему дали приказ p. Программа должна определить, в каком направлении корабль будет двигаться после выполнения приказа.

 

program Ship;

type Courses = (North, West, South, East);

Orders = (Ahead, Back, Left, Right);

var d1, d2: Courses;

p: Orders;

i: integer;

s: string;

Begin

{Запрашиваем у пользователя информацию о курсе и приказе}

writeln('Введите первоначальный курс корабля ');

write('(0-север, 1-запад, 2-юг, 3-восток) ');

readln(i);

d1:=Courses(i);

writeln('Введите приказ, данный кораблю ');

write('(0-прямо, 1-назад, 2-влево, 3-вправо) ');

readln(i);

p:=Orders(i);

{Определяем новый курс}

case p of

Ahead: d2:=d1;

Back: d2:=Courses((ord(d1)+2) mod 4);

Left: d2:=Courses((ord(d1)+1) mod 4);

Right: d2:=Courses((ord(d1)+3) mod 4);

       {-1 - нельзя, так как (Ord(North)-1) mod 4 = -1}

end;

{Выводим результат на экран}

case d2 of

North: s:='север';

West: s:='запад';

South: s:='юг';

East: s:='восток';

end;

writeln('Теперь корабль движется на ' +s);

readln;

end.

 

Ограниченный тип

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

Например,

Var a: 1..25; ch: 'a'..'z';

Здесь переменные а и ch могут принимать значения только из указанного интервала; базовым типом для переменой а является целый тип, а для переменной ch - символьный.

Переменная ограниченного типа сохраняет все свойства переменных базового типа.

Для чего вводится ограниченный тип данных? Использование ограниченного типа делает программу наиболее понятной и наглядной. Например, если в программе переменная b может принимать только значения 3, 4, 5, 6, 7, 8, то лучше описать её следующим образом: Var b: 3..8;, чем Var b: Integer; так как в случае выхода значения b за диапазон 3..8 в первом случае будет выдано диагностическое сообщение, которое поможет найти ошибку. Во втором случае будет получен неправильный результат, что затруднит поиск ошибки. Таким образом, второй вариант описания переменной следует использовать в тех случаях, когда диапазон значений заранее неизвестен либо занимает весь допустимый интервал значений для рассматриваемого типа.

Этот тип также рассмотрим на примере. Пусть в некоторой переменной нужно хранить текущее число, то есть номер дня в месяце. В Турбо Паскале можно задать тип DaysInMonth = 1..31;. Переменные и константы этого типа могут принимать только такие значения, если попытаться задать что-либо другое, то компилятор выдаст ошибку. В качестве границ могут употребляться и отрицательные числа, например Temperature =-60..50;

В качестве базового типа (то есть типа, из которого выбирается диапазон значений) могут использоваться почти все порядковые типы, то есть те, которые хранятся в виде целых чисел. К порядковым типам относятся: все целые типы (byte, integer, и т. п.), char, boolean, перечисляемые типы и ограниченные типы. В качестве базового типа нельзя использовать лишь сам ограниченный тип (трудно представить, как это можно сделать). С учетом этого правила допустимы такие объявления типов:

type SmallLatin = ' a '..' z '; {малые латинские буквы}

MyBoolean = True.. False; {хотя это и бессмысленно}

Holidays = Sat.. Sun; {выходные}

Нельзя в качестве базового типа употребить какой-либо вещественный тип, следующее объявление приведет к ошибке:

type Wrong = -1.25..1.25;

Заметим, что функции Ord, Succ и Pred могут применяться к любым порядковым типам, и, в частности, к ограниченным.

 

Лекция 7. Массивы

Begin

for i:=1 to 10 do begin

write('Введите элемент номер ',i,' -> ');

readln(a[i]);

end;

max:=a[1];

for i:=2 to 10 do

if a[i]>max then max:=a[i];

writeln('Максимум равен ',max);

readln;

end.

 

В качестве типа элементов массива можно использовать все типы, известные нам на данный момент (к ним относятся все числовые, символьный, строковый и логический типы).

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

var Numbers: array [0..1000] of integer;

Names: array [1..10] of string;

Crit: array [sh or tint] of boolean;

CountAll: array [char] of integer;

Count: array ['a'..'z'] of integer;

В следующем примере показано для чего может понадобиться последний тип.

Пример 2. Подсчет количества различных букв в строке.

program CountLetters;

var s: string;

count: array ['a'..'z'] of byte;

ch: char;

i: byte;

Begin

write('Введите строку > ');

readln(s);

for i:=1 to length(s) do

if (s[i]>='a') and (s[i]<='z') then inc(count[s[i]]);

writeln('Количество различных букв в строке: ');

for ch:='a' to 'z' do

if count[ch]<>0 then

writeln(ch,': ',count[ch]);

readln;

end.

Многомерные массивы

При необходимости можно нумеровать массивы не одним индексом а двумя и более. Двумерному массиву соответствует матрица в математике, то есть прямоугольная таблица.

Примеры описаний многомерных массивов:

var Matrix: array [1..4,1..3] of real;

Cube3D: array [1..5,1..5,1..5] of integer;

Рассмотрим пример использования двумерного массива.

Пример 3. Построить календарь на следующий год, то есть при вводе номера месяца и числа выдавать день недели.

program Calendar;

type tWeekDay = (Mon,Tue,Wed,Thu,Fri,Sat,Sun,NoDay);

           {NoDay - нет дня (например, 30.02)}

tCalendar = array [1..12,1..31] of tWeekDay;

var CL: tCalendar;

m,d: byte; {месяц и число}

wd: tWeekDay; {день недели}

 

Begin

   {Строим массив:}

{1. Заполним весь календарь значениями "нет дня":}

for m:=1 to 12 do

for d:=1 to 31 do CL[m,d]:=NoDay;

  {2. Строим массив-календарь:}

m:=1; d:=1;

wd:=Mon;

Repeat

CL[m,d]:=wd;

case m of

4,6,9,11:   if d=30 then begin m:=m+1; d:=1; end else d:=d+1;

1,3,5,7,8,10,12: if d=31 then begin m:=m+1; d:=1; end else d:=d+1;

2:          if d=28 then begin m:=m+1; d:=1; end else d:=d+1;

end;

wd:=tWeekDay((ord(wd)+1) mod 7);

until m=13;

{Выводим на экран:}

repeat

write('Номер месяца > '); readln(m);

write('Число > '); readln(d);

case CL[m,d] of

Mon: writeln('Понедельник');

Tue: writeln('Вторник');

Wed: writeln('Среда');

Thu: writeln('Четверг');

Fri: writeln('Пятница');

Sat: writeln('Суббота');

Sun: writeln('Воскресенье');

NoDay: writeln('Такого дня нет в календаре');

end;

until false;

end.

Сортировка и поиск

В прикладных программах широко распространены два типа операций, связанных с массивами:

1. Упорядочивание элементов массива по возрастанию или убыванию (сортировка)

2. Поиск элемента в массиве.

 

Рассмотрим простейший вариант сортировки массива (сортировка выбором). Пусть есть массив из n элементов; сначала найдём в нём самый маленький среди элементов с номерами 2,3,...n и поменяем местами с первым элементом, затем среди элементов с номерами 3,4,...n найдём наименьший и обменяем со вторым, и т. д. В результате наш массив окажется отсортированным по возрастанию.

program SelectSort;

const n = 10;

var a: array [1..n] of integer;

i,j,jmin,buf: integer;

{ jmin - номер наименьшего элемента,

buf используется при обмене значений двух элементов}

Begin

for i:=1 to 10 do begin

write('Введите элемент номер ',i,' -> ');

readln(a[i]);

end;

 

for i:=1 to n-1 do begin

jmin:=i;

for j:=i+1 to n do

if a[j]<jmin then jmin:=j;

buf:=a[i];

a[i]:=a[jmin];

a[jmin]:=buf;

end;

 

write('Результат: ');

for i:=1 to 10 do write(a[i],' ');

readln;

end.

Другой способ — пузырьковая сортировка, он работает чуть быстрее, чем предыдущий. На первом этапе двигаемся от n-го элемента до 2-го и для каждого из них проверяем, не меньше ли он предыдущего; если меньше, то меняем местами текущий и предыдущий. В итоге первый элемент будет наименьшим в массиве. На втором этапе также проходим элементы от n-го до 3-го, на третьем — от n-го до 4-го, и т. д. В итоге массив будет отсортирован по возрастанию.

program BubbleSort;

...

var i,j: integer;

buf: integer;

Begin

...

for i:=2 to n do

for j:=n downto i do

if a[j]<a[j-1] then begin

   buf:=a[j];

   a[j]:=a[j-1];

   a[j-1]:=buf;

end;

end.

 

Лекция 8. Тип запись

Тип запись, также как и массив, является структурированным типом данных, то есть таким, переменные которого составлены из нескольких частей. В Турбо-Паскале существует возможность объединить в одну переменную данные разных типов (тогда как в массиве все элементы имеют одинаковый тип). Приведём пример такого типа. Пусть в переменной требуется хранить сведения о некотором человеке: ФИО, пол, адрес, телефон. Тогда для хранения этих данных будет удобен такой тип:

type tPerson = record

   Name,Surname,SecondName: string [30];

   Male: boolean;

   Address: string;

   Phone: longint;

end;

 

Объявление переменной типа запись выполняется стандартно, с помощью var. Части записи (в нашем случае: Name, Surname, SecondName, Male, Address, Phone) называются полями. Обращение к полю записи в программе производится с помощью знака ‘.’ (точка). Пример обращения к полям:

 

var p: tPerson;

...

Begin

...

p.Surname:=’Иванов’;

p.Name:=’Иван’;

p.SecondName:=’Иванович’;

...

if (p.Phone<0) or (p.Phone>999999)

then writeln(‘Ошибка’);

...

end.

 

Заметим, что в этом примере постоянно приходится обращаться к полям одной и той же переменной типа запись, и, следовательно, посто