Вводить и выводить значения из массивов целесообразно поэлементно, используя в цикле операторы Readln, Write, Writeln и оператор присваивания.
При описании массивов, задавая числовые пределы изменения индексов, обычно указывают максимально возможное число элементов, которое может быть востребовано в данной программе; при этом допускается, что фактическое количество элементов может оказаться меньше, чем затребовано. Но если значение индекса элемента массива не входит в указанный при описании диапазон, это приведет к ошибке.
4.2.9.1.3. Использование значений массивов, ввод и вывод значений массивов
Как уже отмечалось, для ссылки на отдельные элементы массива используется переменная с индексом: Имя массива[индекс]. Чтобы получить доступ к конкретному элементу массива, в качестве индекса можно использовать не только целое число, соответствующее порядковому номеру этого элемента в массиве, но и выражение, значение которого равно упомянутому целому числу. Например, при обращении к элементам некоторого массива "A: Array[1..100] of Real", в качестве индекса можно использовать любое арифметическое выражение, значением которого будет целое число из диапазона 1..100:
A[56]; A[i+7]; A[i div j] .
Program Vvod_Vivod;
Var i:integer;
A:Array[1..20] of Real;
B:Char;
Begin
Writeln('Введите числа в массив: ');
FOR i:=1 TO 20 DO
begin Write('A[',i,']= '); Readln(A[i]) end;
Writeln('Массив заполнен, будете выводить');
Write('значения на экран? ("Y"-да, "N"-нет)=>');
Readln(B);
IF UpCase(B)="Y" THEN
{если прописной вариант введенной}
FOR i:=1 TO 20 DO Writeln('A[',i,']=',A[i]:6:2);
{буквы является "Y", то}
Readln
End.
Program Prim1;
Const N=10;
Var i:integer;
A,B,C:Array[1..N] of Real;
Begin
FOR i:=1 TO N DO
begin
Write('A[',i,']= '); Readln(A[i]);
Write('B[',i,']= '); Readln(B[i])
end;
FOR i:=1 TO N DO C[i]:=A[i]+B[i];
Writeln('----------------------------------');
FOR i:=1 TO N DO Writeln('C[',i,']=',C[i]:6:1);
Readln
End.
2. Объединим в массиве “С” массивы “А” и “В” так, чтобы их элементы чередовались: элементы из массива “А” занимали нечетные ячейки, а элементы массива “В” - четные.
Program Prim2;
Const N=10;
Var i:integer;
A,B:Array[1..N] of Real;
C:Array[1..N*2] of Real;
Begin
FOR i:=1 TO N DO
begin
Write('A[',i,']= '); Readln(A[i]);
Write('B[',i,']= '); Readln(B[i])
end;
FOR i:=1 TO N DO
begin
C[2*i-1]:=A[i];
C[2*i]:=B[i]
end;
Writeln('------------------------------');
FOR i:=1 TO 2*N DO Writeln('C[',i,']=',C[i]:6:1);
Readln
End.
4.2.9.1.4.Двумерные массивы
Одномерный массив (вектор) имеет вид таблицы из одной строки, ячейки которой заполнены значениями. Рассматривая ДВУМЕРНЫЙ массив, можно провести аналогию с таблицей, имеющей несколько строк и столбцов. Если отдельный элемент одномерного массива мы обозначали именем массива с индексом (А[i]), то для обозначения элемента двумерного массива (матрицы) потребуются два индекса: один - для указания номера строки, другой - для указания номера столбца, на пересечении которых находится нужный элемент: А[i,j]. Двумерные массивы описываются сходно с массивами одномерными:
Const Str=4;
Stolb=5;
Var A:Array[1..Str,1..Stolb] of Real;
Заполнение двумерных массивов данными и вывод данных из двумерного массива осуществляется с использованием двух циклов, один из которых вложен в другой. Внутренний цикл перебирает индексы столбцов, наружный - индексы строк:
FOR i:=1 TO Str DO
FO
4.3. Подпрограммы
4.3.1. Понятие о подпрограмме
В программировании часто встречаются случаи, когда в разных частях программы встречается одна и та же последовательность операторов, решающая одинаковую задачу. Для большей компактности и наглядности, Паскаль позволяет выделять из текста программы повторяющийся фрагмент и записывать его только один раз, представив самостоятельным программным объектом, имеющим собственное имя, при этом допускается многократное обращение к этому объекту в разных местах программы. Объект такого рода называется подпрограммой. Существуют две разновидности подпрограмм: функции и процедуры.
4.3.2. Основные сведения о процедурах
Процедура создается путем описания ее в разделе процедур программы, который начинается словом PROCEDURE:
Program......
Uses........
Label.......
Const.......
Type........
Var.........
Procedure Заголовок процедуры;
Begin
Раздел операторов процедуры
End;
Процедура имеет ту же структуру, что и главная программа (PROGRAM): разделы Label, Const, Type, Var и выполняемую часть.
Procedure имя процедуры;
Label....
Const....
Type.....
Var......
Begin
Раздел операторов
End;
Как можно видеть, имеется только два отличия процедуры от основной программы: процедура начинается с заголовка "Procedure", а не "Program", и заканчивается не точкой, а точкой с запятой.
При создании процедуры, в ее разделе операторов перечисляются команды, которые должны быть выполнены при вызове процедуры из основной программы.
Чтобы выполнить процедуру, надо упомянуть ее имя в требуемом месте программы.
Для демонстрации использования процедур приведем такой пример:
Даны X и Y. Найти: U=Max(X+Y, X*Y); V=Max(0.5, U).
Запишем программу решения этой задачи без использования процедуры:
Program Max;
Var x,y,u,v:Real;
a,b,s:Real;
Begin
Write('x= '); Readln(x);
Write('y= '); Readln(y);
a:=x+y; b:=x*y;
IF a>b THEN s:=a ELSE s:=b;
u:=s;
a:=0.5; b:=u;
IF a>b THEN s:=a ELSE s:=b;
v:=s;
Writeln('U= ',U:5:1, 'V= ',V:5:1);
Readln
End.
В данной программе фигурируют два условных оператора, каждый из которых предназначен для решения сходной задачи: нахождения большего из двух заданных значений и записи в некоторую переменную полученного результата. Эти сходные блоки алгоритма целесообразно выполнять единой прцедурой.
4.3.3. Процедуры без параметров
В приведенном примере условные операторы в точности совпадают друг с другом, поэтому можно считать, что один и тот же условный оператор присутствует в программе дважды. Чтобы избежать двукратного повторения этого оператора в основной программе, представим его процедурой, которой дадим имя "Proced":
Procedure Proced;
begin
IF a>b THEN s:=a ELSE s:=b
end;
Для того, чтобы задействовать созданную процедуру в нужном месте программы, необходимо дополнить текст программы оператором процедуры, представляющим собой имя этой процедуры: "Proced". В результате исходная программа примет такой вид:
Program Max;
Var x,y,u,v:Real;
a,b,s:Real;
Procedure Proced;
begin
IF a>b THEN s:=a ELSE s:=b
end;
Begin
Write('x= '); Readln(x);
Write('y= '); Readln(y);
a:=x+y; b:=x*y; PROCED; u:=s;
a:=0.5; b:=u; PROCED; v:=s;
Writeln('U= ', u:5:1, 'V= ',v:5:1);
Readln
End.
В данной программе блок операторов, объявленный процедурой, невелик, поэтому сокращение текста основой программы несущественно, однако если бы процедура была больше, раздел операторов программы стал бы значительно компактнее.
4.3.4.Процедуры с параметрами
Созданная нами процедура "Proced" неудобна в употреблении, так как поставщиками исходных данных для нее могут быть только переменные "a" и "b". Это приводит к тому, что эта процедура должна всегда сопровождаться указанными переменными, и каждый раз перед обращением к ней приходится присваивать переменным "a" и "b" значения. Чтобы устранить это ограничение и тем самым сделать процедуру более универсальной, удобной в использовании, язык Паскаль позволяет передавать информацию внутрь подпрограммы с помощью ПАРАМЕТРОВ, которые конкретизируются (приобретают значения) при каждом вызове процедуры. Различают две разновидности параметров - параметры формальные и параметры фактические.
ФОРМАЛЬНЫЕ ПАРАМЕТРЫ - это переменные, которые используются только внутри процедуры во время ее работы и играют роль приемника информации, поступающей извне. Поставщиками информации (конкретных значений) для формальных параметров являются ФАКТИЧЕСКИЕ ПАРАМЕТРЫ. Фактическими параметрами могут служить переменные, константы, числа, выражения. При вызовах процедуры в разных частях основной программы, могут меняться фактические параметры, но формальные параметры, находящиеся внутри процедуры и воспринимающие значения от фактических параметров, остаются без изменений, меняются только хранимые ими значения.
Формальные параметры указываются при описании процедуры, при этом должен быть указан тип значений, которые будут получать эти параметры:
Procedure Proced(p1,p2:Real);
begin
IF p1>p2 THEN s:=p1 ELSE s:=p2
end;
Чтобы передать формальным параметрам p1 и p2 конкретные значения, надо при вызове процедуры указать имя процедуры, и затем в круглых скобках задать список фактических параметров; фактическим параметром может быть любое выражение того же типа, что и формальный параметр, в частности- константа или переменная, арифметическое выражение или просто число.
Program Max;
Var x,y,u,v:Real;
s:Real;
Procedure Proced(p1,p2:Real);
begin
IF p1>p2 THEN s:=p1 ELSE s:=p2
end;
begin
Write('x= '); Readln(x);
Write('y= '); Readln(y);
Proced(x+y,x*y); u:=s;
Proced(0.5,u); v:=s;
Writeln('U= ', u:5:1, 'V= ',v:5:1);
Readln
End.
Выполнение процедуры Proced(x+y,x*y) равносильно выполнению такого блока:
Var p1,p2:Real;
begin
p1:=x+y; p2:=x*y;
IF p1>p2 THEN s:=p1 ELSE s:=p2
end;
После того как фактические параметры передали свои значения формальным параметрам, последние играют роль переменных, но только на время выполнения процедуры, после чего прекращают существование. Анализируя предыдущий пример, можно отметить, что в основной программе отпала необходимость использовать переменные "a" и "b" и присваивать им значения перед каждым обращением к процедуре. Применяя в процедурах параметры, следует помнить о том, что формальные и фактические параметры должны соответствовать друг другу. Соответствие формальных и фактических параметров устанавливается путем сопоставления параметров в обоих списках (первый список- перечень формальных параметров, указываемых при описании процедуры, второй список- перечень фактических параметров, указываемых при вызове процедуры). Первый по порядку фактический параметр соответствует первому формальному параметру, второй фактический параметр- второму формальному параметру и т.д. . При этом количество формальных и фактических параметров должно быть одинаково, порядок следования фактических и формальных параметров в списках должен быть один и тот же, тип каждого фактического параметра должен совпадать с типом соответствующего ему формального параметра.
4.3.5. Формальные параметры-значения и формальные параметры-переменные
Различают два вида формальных параметров: параметры-значения и параметры-переменные. Рассмотренные нами формальные параметры являются ПАРАМЕТРАМИ-ЗНАЧЕНИЯМИ.
Формальные параметры-значения являются по-существу внутренними переменными процедуры, после окончания работы процедуры они прекращают свое существование, их значения не могут использоваться вне процедуры, поэтому с помощью параметров-значений нельзя представлять результаты работы процедуры вне тела процедуры, в основной части программы.
Использование параметров-значений позволяет повысить автономность работы процедуры, дает возможность избежать жесткой связи процедуры с переменными из основной программы при вводе исходных данных в процедуру. Вместе с тем, в нашем примере процедура "Proced" остается жестко связанной с основной программой при выводе результатов расчета из процедуры. В используемом нами примере результат вычислений присваивается одной и той же переменной "s", хотя его надо присвоить в одном случае- переменной "u", в другом случае- переменной "v". В итоге, после выполнения процедуры в программе приходится записывать дополнительный оператор присваивания: u:=s или v:=s .
Этот недостаток можно устранить, если в процедуре не фиксировать переменную "s", которой присваивается полученный процедурой результат, а сделать ее формальным параметром процедуры. Такой формальный параметр, способный передавать свое значение любой внешней переменной, называют ПАРАМЕТРОМ-ПЕРЕМЕННОЙ.
Чтобы отличить параметр-переменную от параметра-значения, перед ним в списке формальных параметров описываемой процедуры записывают служебное слово "Var". Для параметра-переменной должен быть указан его тип.
Если фактическим параметром, передающим свое содержимое параметру-значению, может быть любое выражение соответствующего типа (переменная, константа, число, арифметическое выражение), то фактическим параметром для параметра-переменной может быть только переменная.
Запишем наш пример с использованием параметра-переменной:
Program Max;
Var x,y,u,v:Real;
Procedure Proced(p1,p2:Real; Var Rez:Real);
begin
IF p1>p2 THEN Rez:=p1 ELSE Rez:=p2
end;
Begin
Write('x= '); Readln(x);
Write('y= '); Readln(y);
Proced(x+y,x*y,u);
Proced(0.5,u,v);
Writeln('U= ', u:5:1, 'V= ',v:5:1);
Readln
End.
В данном примере процедура использует параметр-переменную "Rez", с помощью которого результат вычислений передается фактическим параметрам: в одном случае- переменной "u", в другом случае - переменной "v".
При передаче результата вычислений переменной "u", работа процедуры равносильна выполнению следующего блока:
Var p1,p2,Rez:Real;
Begin
p1:=x+y; p2:=x*y;
IF p1>p2 THEN Rez:=p1 ELSE Rez:=p2;
u:=Rez
End;
Приведенный выше пример не следует понимать так, будто исходные данные для процедуры могут поставляться лишь формальными параметрами-значениями. Напротив, формальным параметром, воспринимающим данные извне, может быть и параметр-переменная. Допустим, при описании процедуры
Pr(Var a,b,c,d:Real);
часть параметров-переменных может принимать исходные данные, а часть- выдавать в основную программу результаты.
Вопрос о том, как вводить в процедуру исходные данные- с помощью параметров-значений или параметров-переменных, решается в каждом случае индивидуально, исходя из того факта, что для формального параметра-значения фактическим параметром может быть переменная, константа, число, арифметическое выражение или функция, а для формального параметра-переменной фактическим параметром может быть только переменная.
Чтобы понять, в каких случаях использовать параметры-значения, а в каких- параметры-переменные, рассмотрим подробнее процесс передачи данных от фактических параметров формальным в момент обращения к процедуре.
Если формальный параметр определен как параметр-значение, то перед выполнением вызываемой процедуры вычисляется значение фактического параметра, полученный результат помещается во временную память, и только затем значение передается в процедуру непосредственно формальному параметру. Если при этом в качестве фактического параметра указано даже простейшее выражение в виде переменной или константы, все равно процедуре будет передана лишь копия содержимого переменной (константы), временно хранящаяся в памяти. В тех случаях, когда формальный параметр определен как параметр-переменная, ему при вызове процедуры передается от фактического параметра содержимое самой переменной, а не копия.
Какие-либо изменения величины параметра-значения в разделе операторов процедуры не воспринимаются вызывающей программой, поскольку в этом случае изменяется лишь копия фактического параметра; если же в процедуре изменяется содержимое параметра-переменной, это ведет к изменению связанного с ним фактического параметра в основной программе:
Program Param;
Var a,b:integer;
Procedure Proc(c:integer; var d:integer);
begin
c:=c+c; d:=d+d; Writeln(c:3,d:3)
end;
Begin
a:=1; b:=2;
Writeln(a:3,b:3);
Proc(a,b);
Writeln(a:3,b:3);
Readln
End.
При выполнении этой программы на экран будут выведены такие данные:
Удвоение формального параметра-значения "с" в процедуре не повлекло изменения значения соответствующего ему фактического параметра (переменной "а" из основной программы). Изменение второго формального параметра, описанного как параметр-переменная "d", передалось в основную программу, потому что одновременно изменился фактический параметр (переменная "b").
4.3.6. Использование массивов в качестве параметров процедур
Как известно, массив можно рассматривать не только как группу упорядоченных переменных, объединенных одним именем, но и как одну переменную, называемую полной переменной. Если имеются две полные переменные “A” и “B”, одинаковые по размерам и типу хранимых ими значений, то значение “A” может быть присвоено переменной “B” с помощью одного оператора присваивания B:=A; т.е. не обязательно передавать значения из одного массива в другой поэлементно. Таким образом, массивам внутри процедуры можно передавать значения извне с помощью формальных и фактических параметров, оформленных в виде полных переменных. При использовании массивов в качестве параметров процедур существует ряд ограничений. Во-первых, нельзя обрабатывать одной и той же процедурой массивы разных типов и размеров. Во-вторых, в заголовке процедур для указания типов формальных параметров- полных переменных запрещается использовать безымянные типы, например A:Array[1..20] of Real.Правильно будет предварительно описывать имя типа массива в разделе описаний программы:
Type
Mas1=Array[1..20] of Real;
...............................
Procedure Proced(Var A:Mas1);
begin
...............................
end;
Пример использования массивов в качестве формальных и фактических параметров процедуры:
Требуется найти U=Max{Xi}, V=Max{Yi}, где i= 1,2,3,...,N.
Поскольку в этом примере дважды используется алгоритм нахождения наибольшего элемента массива, его удобно оформить в виде процедуры.
Program Primer;
Const N=20;
Type Mas=Array[1..N] of Real;
Var i:integer;
u,v:Real;
x,y:Mas;
Procedure Max(a:Mas; Var s:Real);
begin
s:=A[1];
FOR i:=1 TO N DO IF A[i]>s THEN s:=A[i]
end;
Begin
FOR i:=1 TO N DO
begin
Write('X[',i,']= '); Readln(x[i]);
Write('Y[',i,']= '); Readln(y[i]);
end;
Max(x,u); Max(y,v);
Writeln('U= ',U:5:1,'V= ',V:5:1);
Readln
End.
Поскольку в данной программе фактическим параметром является переменная (массив в виде полной переменной), то в качестве формального параметра, принимающего исходные данные, может быть использован не только параметр-значение, но и параметр-переменная: Procedure Max(Var A:Max; Var S:Real).
На первый взгляд, нет никакой разницы, как передаются значения массива в процедуру- с помощью параметра-значения или параметра-переменной, однако разница есть и она существенна.
Как уже говорилось, при объявлении формальным параметром параметра-значения, фактический параметр копируется во временную память, а затем - из памяти в процедуру. Если в этом случае фактическим параметром будет большой массив, то на дополнительное копирование уйдет много времени и памяти, поэтому при обработке процедурой крупных массивов лучше использовать параметр-переменную.
4.3.7. Принцип локализации
Все задействованные в процедуре программные объекты (переменные, константы и т.п.) можно описывать в основной программе, однако это не рационально, поскольку излишне увеличивается основной раздел описаний и не экономно используется оперативная память компьютера Кроме того, изменения, вносимые в текст процедуры и затрагивающие имена и типы переменных, потребуют соответствующих изменений в основной программе, что осложняет ее отладку
Указанные трудности в Паскале устраняются благодаря ПРИНЦИПУ ЛОКАЛИЗАЦИИ, суть которого состоит в том, что вводимые (описываемые) в какой-либо процедуре программные объекты (метки, константы, переменные, процедуры и функции, используемые для внутри-процедурных потребностей) существуют только в пределах данной процедуры.
Имена, используемые для описания переменных, констант и других программных объектов внутри подпрограммы, называются ЛОКАЛЬНЫМИ для данной подпрограммы. Программные объекты, описанные в основной программе, называются ГЛОБАЛЬНЫМИ.
Использование ЛОКАЛЬНЫХ ПОДПРОГРАММ означает использование вложенных модулей (подпрограмма вызывает вставленную в нее другую подпрограмму). При создании программ, имеющих вложенные модули, следует придерживаться следующих правил:
желательно описывать программные объекты в том модуле (подпрограмме), где они используются;
если одна и та же переменная или константа используется в двух и более модулях, то эту переменную (константу) следует описать в самом внешнем модуле, содержащем все остальные;
если переменная, используемая в процедуре, должна сохранить свое значение до следующего вызова этой процедуры, то переменную надо описать во внешнем модуле, содержащем данную процедуру.
Пример: задан выпуклый четырехугольник ABCD с диагональю AC. Найти его площадь.
Четырехугольник можно рассматривать как два треугольника со сторонами a,b,c. Дважды вычислив площадь треугольника (S) и сложив полученные значения, мы найдем искомый результат.
Как видно из формул, решение задачи предполагает двукратное использование процедуры вычисления площади треугольника, оперирующей величиной "p", имеющей вспомогательный характер. Составим программу, решающую эту задачу:
Program Primer;
Var a,b,c,d,e,s1,s2:Real;
Procedure STR(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
Write('A= '); readln(A);
{вводим длины сторон и диагональ}
Write('B= '); readln(B);
{четырехугольника}
Write('C= '); readln(C);
Write('D= '); readln(D);
Write('E= '); readln(E);
STR(A,B,E,S1);
STR(D,E,C,S2);
Writeln('Площадь фигуры= ',S1+S2:5:1);
Readln
End.
ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕв теле процедуры имеют тот же смысл, что и до входа в процедуру, и их значение может быть изменено процедурой. Таким образом, с помощью глобальных переменных можно осуществлять непосредственную связь процедуры с внешним блоком, минуя связь через параметры.
ЛОКАЛЬНЫЕ ПЕРЕМЕННЫЕописываются в теле процедуры, их используют в вычислениях внутри процедуры, но не для передачи значений вовне. Переменная, локализованная в теле процедуры, при выходе из процедуры прекращает существование, а при каждом очередном вхождении в процедуру возникает заново.
