Главная | Обратная связь | Поможем написать вашу работу!

Преобразования типов и действия над ними

Как уже говорилось, тип переменной позволяет не только устанавливать длину ее внутреннего представления, но и контролировать те действия, которые выполняются над ней в программе. Контроль за использованием переменных еще на этапе компиляции программы - важное преимущество Турбо Паскаля перед другими языками программирования, в которых допускается автоматическое преобразование типов. В Турбо Паскале почти невозможны неявные (автоматические) преобразования типов. Исключение сделано только в отношении констант и переменных типа INTEGER (целые), которые разрешается использовать в выражениях типа REAL (вещественные). Если, например, переменные X и Y описаны следующим образом:

var

х: Integer;

у: Real;

то оператор

у:= х + 2;

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

х:= 2.0;

будет неверным, так как автоматическое преобразование типа REAL (константа 2.0 содержит десятичную точку и, следовательно, принадлежит к типу REAL) в тип INTEGER в Турбо Паскале запрещено.

Разумеется, запрет на автоматическое преобразование типов еще не означает, что в Турбо Паскале нет средств преобразования данных. Они, конечно же, есть, но их нужно использовать явно (подробнее об этом см. гл.4). Для преобразования данных в языке существуют встроенные функции, которые получают в качестве параметра значение одного типа, а возвращают результат в виде значения другого типа. В частности, для преобразования REAL в INTEGER имеются даже две встроенные функции такого рода: ROUND округляет REAL до ближайшего целого, a TRUNC усекает REAL путем отбрасывания дробной части.

Например, ошибочным будет оператор

х:= у/х;

но правильным

х:= round(у/х);

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

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

Для преобразования данных типа CHAR (символ) в целое число предназначена функция ORD, обратное преобразование INTEGER в CHAR осуществляет функция CHR.

С помощью следующей несложной программы (пример 2.3) Вы сможете узнать внутренний код произвольного символа.

Пример 2.3

Program Code_pf_Char;

{Программа читает символ с клавиатуры и выводит на экран

этот символ несоответствующий ему внутренний код}

var

ch: Char; {В эту переменную читается символ}

begin

Write('Введите любой символ: ');

ReadLn(ch); {Читаем один символ}

WriteLn(ch, ' = ',ord(ch)); {Преобразуем его к целому и выводим на экран}

END.

Обратите внимание: при вызове

WriteLntch,' = ',ord(ch));

третьим параметром обращения указан вызов функции ORD (СН), что с точки зрения языка является выражением; как мы увидим дальше (см. гл.8), во многих случаях при вызове процедур и функций в качестве параметров вызова можно указывать не только переменные или константы, но и выражения с их участием.

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

Конечно же, в Турбо Паскале есть все четыре арифметические операции над переменными REAL И INTEGER:

+ - сложение;

- - вычитание;

* - умножение;

/ - деление вещественное;

div - деление целочисленное.

Наличие двух операций деления есть еще одно проявление основополагающего принципа Турбо Паскаля: программист должен явно подтверждать компилятору, что он готов к возможным последствиям преобразования типов. Если, например, в языке Фортран используется выражение 1/2, то результат этого выражения будет зависеть от того, переменной какого типа он будет присвоен: если N есть переменная целого типа, а Х- вещественного, то в программе на Фортране присваивания

N = 1/2

X = 1/2

дадут значения 0 для N и 0.5 для X. В Турбо Паскале такой двусмысленности нет: выражение 1/2 всегда имеет значение 0.5 и поэтому оператор

var

N:Integer;

begin

N:= 1/2;

просто недопустим. В то же время допустимый в Турбо Паскале оператор

var

X: Real;

begin

X:= 1 div 2;

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

Для данных типа INTEGER в Турбо Паскале есть еще одна операция MOD - получение остатка от целочисленного деления. Например:

5 mod 2 = 1

31 mod 16 = 15

18 mod 3 = 0

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

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

При работе с целыми числами могут оказаться полезными две процедуры (здесь и далее в квадратных скобках указываются необязательные параметры):

DEC (X [, N]) - уменьшает содержимое переменной X на значение выражения N (если N не задано, то на 1); тип переменной X и выражения N - INTEGER (точнее, любой целый, см. гл. 4);

INC (X [, N]) - увеличивает значение X на N (если N не задано, то на 1).

Над символами и строками символов определена единственная операция - сцепление двух строк. Операция обозначается символом «+». Например, программа

var

st: String;

begin

st:= 'Турбо'+'-'+'Паскаль';

WriteLn(st);

end.

напечатает строку

Турбо-Паскаль

Все остальные действия над строками и символами реализуются с помощью встроенных процедур и функций (см. гл.4).

И, наконец, об операциях отношения и логических операциях.

Над данными типа REAL, INTEGER, CHAR, STRING определены следующие операции отношения (сравнения):

= - равно;

<> - не равно;

< - меньше;

> - больше;

<= - меньше или равно,

>= - больше или равно.

В операциях сравнения должны участвовать однотипные операнды. Исключение сделано опять-таки в отношении REAL и INTEGER, которые могут сравниваться друг с другом. Результат применения операции отношения к любым операндам имеет тип BOOLEAN.

Сравнение двух строк осуществляется следующим образом. Символы строк сравниваются попарно друг с другом так, что первый символ первой строки сравнивается с первым символом второй строки, второй символ первой строки - со вторым символом второй и т.д. Символы сравниваются путем сравнения их кодов во внутреннем представлении (см. гл. 4). Если одна строка короче другой, недостающие символы заменяются нулем. Отношение первой несовпадающей друг с другом пары символов и принимается за отношение двух строк.

При сравнении данных типа BOOLEAN учитывается внутреннее соглашение Турбо Паскаля, в соответствии с которым FALSE есть нулевой байт, a TRUE - байт с единицей в младшем разряде. Заметим, что функция ORD преобразует к целому не только символы, но и логические величины, поэтому

ord(false) = 0,

ord(true) = 1.

В Турбо Паскале определены следующие логические операции:

not - логическое НЕ; or - логическое ИЛИ;

and - логическое И; хоr - исключающее ИЛИ.

Логические операции применимы к операндам целого и логического типов. Если операнды - целые числа, то результат логической операции есть тоже целое число (подробнее об этом сказано в гл.4). Логические операции над логическими данными дают результат логического типа.

При вычислении выражений любого типа приоритет вычислений определяется расставленными скобками, а при их отсутствии - по табл. 2.1 (в порядке убывания приоритета).

Таблица 2.1 Приоритет операций

Приоритет	Операция
	not, @
	*, /, div, mod, and, shl, shr
	+, -, or, xor
	=, <>, >, >=, <, <=, in

Примечание. Операции @ (получение адреса), shl (сдвиг влево), shr (сдвиг вправо) и in (принадлежность к множеству) описаны в гл.4.

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

а = b and с < d

вызовет сообщение о синтаксической ошибке, так как сначала выполнится операция b and с. Правильным будет выражение:

(а = b) and (с < d)

ОПЕРАТОРЫ ЯЗЫКА

С одним из наиболее часто используемых операторов языка Турбо Паскаль - оператором присваивания мы уже познакомились. Ниже рассматриваются остальные операторы языка.

2.4.1. Составной оператор и пустой оператор

Составной оператор - это последовательность произвольных операторов программы, заключенная в операторные скобки - зарезервированные слова begin... end. Составные операторы - важный инструмент Турбо Паскаля, дающий возможность писать программы по современной технологии структурного программирования (без операторов перехода GOTO).

Язык Турбо Паскаль не накладывает никаких ограничений на характер операторов, входящих в составной оператор. Среди них могут быть и другие составные операторы - Турбо Паскаль допускает произвольную глубину их вложенности:

begin

.......

begin

.......

begin

......

end;

......

end;

......

end;

Фактически, весь раздел операторов, обрамленный словами begin... end, представляет собой один составной оператор. Поскольку зарезервированное слово end является закрывающей операторной скобкой, оно одновременно указывает и конец предыдущего оператора, поэтому ставить перед ним символ «;» необязательно, и далее во всех примерах мы не будем этого делать. Наличие точки с запятой перед end в предыдущих примерах означало, что между последним оператором и операторной скобкой end располагается пустой оператор. Пустой оператор не содержит никаких действий, просто в программу добавляется лишняя точка с запятой. В основном пустой оператор используется для передачи управления в конец составного оператора.

2.4.2. Условный оператор

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

Структура условного оператора имеет следующий вид:

IF <условие> THEN <оператор1> ELSE <оператор2>,

где IF, THEN, ELSE - зарезервированные слова (если, то, иначе); <условие> - произвольное выражение логического типа; <оператор1>, <оператор2> - любые операторы языка Турбо Паскаль.

Условный оператор работает по следующему алгоритму. Вначале вычисляется условное выражение <условие>. Если результат есть TRUE (истина), то выполняется <оператор1>, а <оператор2> пропускается; если результат есть FALSE (ложь), наоборот, <оператор1> пропускается, а выполняется <оператор2>. Например:

var

х, у, max: Integer;

begin

.......

if x > max then

у:= max else

y:= x;

При выполнении этого фрагмента переменная Y получит значение переменной X, если только это значение не превышает МАХ, в противном случае Y станет равно МАХ.

Часть ELSE <оператор2> условного оператора может быть опущена. Тогда при значении TRUE условного выражения выполняется <оператор1>, в противном случае этот оператор пропускается:

var

х, у, max: Integer;

begin

.......

if x > max then

max:= x;

Y:= x;

В этом примере переменная Y всегда будет иметь значение переменной X,а в МАХ запоминается максимальное значение X.

Поскольку любой из операторов <оператор1> и <оператор2> может быть любого типа, в том числе и условным, а в то же время не каждый из «вложенных» условных операторов может иметь часть ELSE <оператор2>, то возникает неоднозначность трактовки условий. Эта неоднозначность в Турбо Паскале решается следующим образом: любая встретившаяся часть ELSE соответствует ближайшей к ней «сверху» части THEN условного оператора. Например:

var

a,b,c,d: Integer; begin

a:= 1; b:= 2; c= 3; d:= 4;

if a > b then

if с < d then

if с < 0 then

с:= 0 else

a:= b; {а равно 1}

if a > b then

if с then

с:= 0

else

a:= b; {а равно 2}

Рассмотрим программу (пример 2.4), которая вводит произвольное десятичное целое число в диапазоне 0...15, преобразует его к шестнадцатеричному и выводит на экран полученный результат.

Пример 2.4

Program Hex;

{Программа вводит с клавиатуры целое число в диапазоне от 0 до 15, преобразует его к шестнадцатеричной системе счисления и выводит результат на экран}

var

n: Integer; {Вводимое число}

ch: Char; {Результат}

begin

Write (',n = ');

ReadLn(n); { Вводим число }

{Проверяем число на принадлежность к диапазону 0...15}

if (n >= 0) and (n <= 15) then

begin {Да, принадлежит диапазону}

if n < 10 then

ch:= chr(ord('0') + n)

else

ch:= chr(ord('A') + n- 10);

WriteLn('n = ',ch)

end

else {He принадлежит диапазону}

WriteLn('Ошибка')

end.

В шестнадцатеричной системе счисления используется 16 цифр в каждом разряде: цифры 0...9 обозначают первые 10 возможных значений разряда, буквы A...F - остальные шесть.

В программе учитывается непрерывность и упорядоченность множеств цифр 0...9, букв A...F и их кодов (см. гл.4).

2.4.3. Операторы повторений

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

Счетный оператор цикла FOR имеет такую структуру:

FOR <пар_цик>:= <нач_знач> ТО <кон_знач> DO <оператор>.

Здесь FOR, TO, DO - зарезервированные слова (для, до, выполнить);

<пар_цик> - параметр цикла - переменная типа INTEGER (точнее, любого порядкового типа, см. гл.4);

<нач_знач> - начальное значение - выражение того же типа;

<кон_знач> - конечное значение - выражение того же типа;

<оператор> - произвольный оператор Турбо Паскаля.

При выполнении оператора FOR вначале вычисляется выражение <нач_знач> и осуществляется присваивание <пар_цик>: = <нач_знач>. После этого циклически повторяется:

· проверка условия <пар_цик> <= <кон_знач>; если условие не выполнено, оператор FOR завершает свою работу;

· выполнение оператора <оператор>;

· наращивание переменной <пар_цик> на единицу.

В качестве иллюстрации применения оператора FOR рассмотрим программу, осуществляющую ввод с клавиатуры произвольного целого числа N и вычисление суммы всех целых чисел от 1 до N (пример 2.5).

Пример 2.5

Program Summ_of_Integer;

{Программа вводит целое положительное число N и подсчитывает сумму всех целых чисел от 1 до N}

var

i, n, s: Integer;

begin

Write('N = ');

ReadLn(n);. { Вводим N}

s:= 0; {Начальное значение суммы}

for i: = 1 to n do {Цикл подсчета суммы}

s: = s + i;

writeln('Сумма = ',s) {Выводим результат}

end.

Отметим два обстоятельства. Во-первых, условие, управляющее работой оператора FOR, проверяется перед выполнением оператора <оператор>: если условие не выполняется в самом начале работы оператора FOR, исполняемый оператор не будет выполнен ни разу. Другое обстоятельство - шаг наращивания параметра цикла строго постоянен и равен (+1). Существует другая форма оператора:

FOR<пар_цик>: = <нач_знач> DOWNTO <кон_знач> DO <оператор>

Замена зарезервированного слова ТО на DOWNTO означает, что шаг наращивания параметра цикла равен (-1), а управляющее условие приобретает вид <пар_цик> = <кон_знач>.

Пример 2.5 можно модифицировать так, чтобы сделать его пригодным для подсчета любых сумм - положительных и отрицательных:

..................

s:= 0;

if n >= 0 then

for i:= 1 to n do

s:= s + i else

for i:= -1 downto n do s: = s + i;

...............

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

Оператор цикла WHILE с предпроверкой условия:

WHILE <условие> DO <оператор>.

Здесь WHILE, DO - зарезервированные слова (пока [выполняется условие], делать);

<условие> - выражение логического типа;

<оператор> - произвольный оператор Турбо Паскаля.

Если выражение <условие> имеет значение TRUE, то выполняется <оператор>, после чего вычисление выражения <условие> и его проверка повторяются. Если <условие> имеет значение FALSE, оператор WHILE прекращает свою работу.

Рассмотрим пример 2.6, иллюстрирующий использование оператора WHILE. Найдем так называемое «машинное эпсилон» - такое минимальное, не равное нулю вещественное число, которое после прибавления его к 1.0 еще дает результат, отличный от 1.0.

Пример 2.6

Program EpsilpnDetect;

{Программа вычисляет и выводит на экран значение "машинного эпсилон"}

var

epsilon: Real;

begin

epsilon:= 1;

while epsilon/2 + 1 > 1 do

epsilon:= epsilon/2

WriteLn('Машинное эпсилон = ',epsilon)

end.

У читателя, привыкшего к непрерывной вещественной арифметике, может вызвать недоумение утверждение о том, что в дискретной машинной арифметике всегда существуют такие числа 0<X<eps, что 1.0+Х=1.0. Дело в том, что внутреннее представление типа REAL может дать «лишь» приблизительно 1014 возможных комбинаций значащих разрядов в отведенных для него 6 байтах. Конечно же, это очень большое число, но оно несопоставимо с бесконечным множеством вещественных чисел. Аппроксимация бесконечного непрерывного множества вещественных чисел конечным (пусть даже и очень большим) множеством их внутреннего машинного представления и приводит к появлению «машинного эпсилон».

Оператор цикла REPEAT... UNTIL с постпроверкой условия:

REPEAT <тело_цикла> UNTIL <условие>.

Здесь REPEAT, UNTIL- зарезервированные слова (повторять до тех пор, пока не будет выполнено условие);

<тело_цикла> - произвольная последовательность операторов Турбо Паскаля;

<условие> - выражение логического типа.

Операторы <тело_цикла> выполняются хотя бы один раз, после чего вычисляется выражение <условие>: если его значение есть FALSE, операторы <тело_цикла> повторяются, в противном случае оператор REPEAT... UNTIL завершает свою работу.

Для иллюстрации применения оператора REPEAT... UNTIL модифицируем программу из примера 2.3. Модификация (пример 2.7) состоит в том, что программа будет все время повторять цикл ввода символа и печати его кода до тех пор, пока очередным символом не будет символ CR (вводится клавишей Enter).

Пример 2.7

Program Codes_of_Chars;

{Программа вводит символ и выводит на экран его код. Для завершения работы программы нужно дважды нажать Enter}

var

ch: Char; {Вводимый символ}

const

CR = 13; {Код символа CR}

begin

repeat

ReadLn(ch);

WriteLn(ch,' = ',ord(ch))

until ord(ch) = CR

end.

Обратите внимание: пара REPEAT... UNTIL подобна операторным скобкам begin... end, поэтому перед UNTIL ставить точку с запятой необязательно.

Для гибкого управления циклическими операторами FOR, WHILE и REPEAT в состав Турбо Паскаля включены две процедуры:

BREAK - реализует немедленный выход из цикла; действие процедуры заключается в передаче управления оператору, стоящему сразу за концом циклического оператора;

CONTINUE - обеспечивает досрочное завершение очередного прохода цикла; эквивалент передачи управления в самый конец циклического оператора.

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

2.4.4. Оператор выбора

Оператор выбора позволяет выбрать одно из нескольких возможных продолжений программы. Параметром, по которому осуществляется выбор, служит ключ выбора -выражение любого порядкового типа (любого из рассмотренных, кроме типов REAL и STRING, см. гл. 4).

Структура оператора выбора такова:

CASE <ключ_выбора> OF <список_выбора> [ELSE <операторы>] END

Здесь CASE, OF, ELSE, END - зарезервированные слова (случай, из, иначе, конец);

<ключ_выбора> - ключ выбора;

<список_выбора> - одна или более конструкций вида:

<константа_выбора>: <оператор>;

<константа_выбора> - константа того же типа, что и выражение<ключ_выбopa>;

<операторы> - произвольные операторы Турбо Паскаля.

Оператор выбора работает следующим образом. Вначале вычисляется значение выражения <ключ_выбора>, а затем в последовательности операторов <список_выбора> отыскивается такой, которому предшествует константа, равная вычисленному значению. Найденный оператор выполняется, после чего оператор выбора завершает свою работу. Если в списке выбора не будет найдена константа, соответствующая вычисленному значению ключа выбора, управление передается операторам, стоящим за словом ELSE. Часть ELSE <оператор> можно опускать. Тогда при отсутствии в списке выбора нужной константы ничего не произойдет и оператор выбора просто завершит свою работу.

Составим программу (пример 2.8), имитирующую работу микрокалькулятора. Программа вводит две строки: первая содержит два произвольных числа, разделенных пробелом, вторая - символ арифметического действия, например:

2 2

или

18.35 0.12

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

Пример 2.8

Program Calc;

{Программа вводит два числа в первой строке и один из знаков +, -, *, / - во второй и выводит на экран результат соответствующего арифметического действия}

var

operation: Char; {Знак операции}

х, у, z: Real; {Операнды и результат}

stop: Boolean; {Признак ошибочной операции и останова}

begin

stop:= false;

repeat

WriteLn; {Пустая строка-разделитель}

Write('x,y= ');

ReadLn(x,y);

Write('операция: ');

ReadLn(operation);

case operation of

' + ':	z: =	x + y;
' - ':	z: =	x - y;
' * ':	z: =	x * y;
' / ':	z: =	x / y;
else
stop	:= true;
end;
if not	stop	then

WriteLn('результат=',z)

until stop

end.

Любому из операторов списка выбора может предшествовать не одна, а несколько констант выбора, разделенных запятыми. Например, следующая программа при вводе одного из символов: у или Y выведет на экран слово «Да», а при вводе n или N - слово «Нет»:

var

ch: Char;

begin

ReadLn (ch);

case ch of

'n','N': WriteLn ('Нет');

'y','Y': WriteLn ('Да')

end

end.

2.4.5. Метки и операторы перехода

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

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

Оператор перехода имеет вид:

GOTO <метка>.

Здесь GOTO - зарезервированное слово (перейти [на метку]); <метка> - метка.

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

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

label

loop, 1b1, 1b2;

begin

.......

goto 1b1;

.......

loop:......

.......

1b1:1b2:......

........

goto 1b2;

.......

Действие оператора GOTO состоит в передаче управления соответствующему меченному оператору.

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

метка, на которую ссылается оператор GOTO, должна быть описана в разделе описаний и она обязательно должна встретиться где-нибудь в теле программы;

метки, описанные в процедуре (функции), локализуются в ней, поэтому передача управления извне процедуры (функции) на метку внутри нее невозможна.

МАССИВЫ

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

При описании массива необходимо указать общее число входящих в массив элементов и тип этих элементов. Например:

var

а: array [1..10] of Real;

b: array [0..50] of Char;

с: array [-3..4] of Boolean;

Как видим, при описании массива используются зарезервированные слова ARRAY и OF (массив, из). За словом ARRAY в квадратных скобках указывается тип-диапазон, с помощью которого компилятор определяет общее число элементов массива. Тип-диапазон (подробнее см. в гл.4) задается левой и правой границами изменения индекса массива, так что массив А состоит из 10 элементов, массив В - из 51, а массив С - из 8 элементов. За словом OF указывается тип элементов, образующих массив.

Доступ к каждому элементу массива в программе осуществляется с помощью индекса - целого числа (точнее, выражения порядкового типа, см. гл.4), служащего своеобразным именем элемента в массиве (если левая граница типа-диапазона равна 1, индекс элемента совпадает с его порядковым номером). При упоминании в программе любого элемента массива сразу за именем массива должен следовать индекс элемента в квадратных скобках, например:

var

a: array [1..10] of Integer;

b: array [0..40] of Char;

c: array [-2..2] of Boolean;

k: Integer; begin

b[17]:= 'F1;

c[-2]:= a[l] > [2];

for k: = 1 to 10 do a[k]:= 0;

...

end.

В правильно составленной программе индекс не должен выходить за пределы, определенные типом-диапазоном. Например, можно использовать элементы А[1], В[38], С[0], но нельзя A[0] или С[38] (определение массивов см. выше). Турбо Паскаль может контролировать использование индексов в программе на этапе компиляции и на этапе счета программы.

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

Пример 2.9

Program Average;

{Программа создает массив из N случайных целых чисел, равномерно распределенных в диапазоне от 0 до MAX_VALUE-1, подсчитывает среднее арифметическое этих чисел, а также минимальное и максимальное из них.}

const

N = 1000;

MAX_VALUE = 100+1; {Диапазон значений случайных чисел}

var

m: array [1..N] of Integer; {Массив чисел}

i: Integer; {Индекс массива}

max, min: Integer; {Максимальное и минимальное число}

s: Real; {Сумма чисел}

begin

{Наполняем массив случайными числами:}

for i:= 1 to N do

m[i]:= random(MAX_VALUE); {Задаем начальные значения переменных:}

s:= 0;

max: = m [ 1 ];

min: = m [ 1 ];

{Цикл вычисления суммы всех случайных чисел и поиска минимального и максимального:}

for i:= 1 to N do

begin

s: = s + m [ i ];

if m[i] < min then

min:= m[i]

else if m[i] > max then

max:= m[i]

end;

{Вычисляем среднее значение и печатаем результат:}

WriteLn('MMH = ',min,' Макс = ', max, ' Среднее = ',s/N)

end.

Для создания массива используется встроенная функция RANDOM (MAX), которая возвращает случайное целое число, равномерно распределенное в диапазоне от 0 до МАХ-1 (МАХ- параметр обращения).

⇐ Предыдущая 1 2 3 456 7 8 9 10 Следующая ⇒