Из предыдущего раздела мы узнали, что параметры подпрограмм описываются как [Var] имя : имя типа , это правда, но не вся правда - существует еще два способа описания параметров, первый из которых называется “открытый массив”, а второй - “нетипизированный параметр”. Параметр-открытый массив (это всегда массив) описывается в виде:
имя : Array Of тип;
где тип - тип элемента массива (может быть любым, в том числе и массивом, но не открытым массивом). Это описание отличается от обычного описания массива отсутствием типа индекса в квадратных скобках. Аргумент, сопоставляемый такому параметру, должен быть массивом с элементами соответствующего типа, а вот тип индекса (следовательно, и длина массива) может быть любым. Внутри подпрограммы считается, что индексы открытого массива числовые (хотя у аргумента они могут быть и символьные и логические), и индекс первого элемента массива равен нулю. Чтобы узнать индекс последнего элемента открытого массива, можно использовать уже известную нам стандартную функцию High.Эта функция для открытого массива возвращает как раз индекс последнего элемента, или количество элементов массива без единицы (это одно и то же, так как первый индекс равен нулю). Функция Low также применима к открытым массивам, но она менее интересна, так как всегда возвращает ноль. Отметим, что функции Low и High применимы и к обычным массивам, в этом случае они возвращают наименьшее и наибольшее значение индекса. Чтобы лучше понять, что такое открытые массивы и зачем они нужны, напишем процедуру, которая будет получать одномерный числовой массив и находить в нем наименьший элемент и его индекс.
Const N=1000;
Type T_Array = Array[1..N] Of Real;
Procedure Minimum(x : T_Array; Var min : Real; Var index : Word);
Var j : Word;
Begin
index:=1;
For j:=2 To N Do If x[index]>x[j] Then index:=j;
min:=x[index];
End;
Var A : T_Array;
m : Real;
k : Word;
Begin
<вычисление элементов массива A>
Minimum(A,m,k);
WriteLn(‘Наименьший элемент массива равен ‘,m,’ , его индекс ‘,k);
End.
Конечно, мы легко решили эту задачу, но пусть нам необходимо найти наименьший элемент не только в массиве A, но и в массиве B : Array[-100..200] Of Real, и в массиве C : Array[#0..#127] Of Real . Написать еще две процедуры - это решение, но самое плохое решение из всех возможных. Можно передавать в процедуру начальное и конечное значения индекса, но и это не выход, потому что, во-первых, сами индексы имеют разные типы, и во-вторых, все равно типы массивов разные, а в списке параметров нужно указать совершенно определенный тип. Параметр-открытый массив позволяет преодолеть эти трудности :
Procedure Mimimum_1(Var x : Array Of Real; Var min : Real; Var index : Word);
Var j : Word;
Begin
index:=0;
For j:=1 To High(x) Do
If x[infex]>x[j] Then index:=j;
min:=x[index];
End;
Var A: Array[1..1000] Of Real;
B: Array[-100..200] Of Real;
C: Array[#0..#127] Of Real;
m: Real;
k : Word;
Begin
<Вычисление элементов массивов A,B,C>
Minimum_1(A,m,k);
WriteLn(‘Наименьший элемент массива А равен ‘,m,’ его индекс ‘ ,Low(A)+k);
Minimum_1(B,m,k);
WriteLn(‘Наименьший элемент массива B равен ‘,m,’ его индекс ‘ ,Low(B)+k);
Minimum_1(C,m,k);
WriteLn(‘Наименьший элемент массива C равен ‘,m,’ его индекс ‘ ,Chr(Ord(Low(C))+k));
End.
Задача решена, при выводе индекса наименьшего элемента массива C потребовалось использование функций Ord и Сhr , так как Паскаль запрещает складывать символы и числа. Наша процедура стала универсальной - она может работать с любым массивом, лишь бы тип его элементов был Real.
Теперь используем в той же задаче еще одну возможность - нетипизированный параметр. Нетипизированные параметры описываются в виде Var имя ; то есть тип параметра не указывается вовсе. Аргументом, сопоставляемым такому параметру, может быть скалярная переменная любого типа, массив любой размерности с элементами любого типа и вообще любой объект, обладающий адресом. В подпрограмму передается лишь адрес, начиная с которого аргумент записан в памяти компьютера. Но работать в подпрограмме непосредственно с нетипизированным параметром невозможно, поэтому прежде чем выполнять над ним какие-либо операции, нужно как-то его преобразовать. В нашей задаче о наименьшем элементе необходимо “сделать” нетипизированный параметр одномерным массивом вещественных чисел. В языке Паскаль для этого есть два способа - явное преобразование типа и совмещение по памяти. Мы уже умеем явно преобразовывать тип целочисленных выражений, например LongInt(10), но возможности явного преобразования типа этим не исчерпываются, в частности, нетипизированный параметр можно преобразовать к любому типу с помощью операции имя типа(параметр); используем эту возможность в нашей задаче.
Procedure Minimum_2(n : Word; Var x; Var min : Real; Var index : Word);
Var j : Word;
Type T = Array[1..10922] Of Real;
Begin
index:=1;
For j:=2 To n Do
If T(x)[index]>T(x)[j] Then index:=j;
min:=T(x)[index];
End;
В процедуре Minimum_2 появился дополнительный параметр n - длина массива, без него не обойтись, так как иначе неизвестно, сколько элементов следует проверить. Конструкция T(x)[j]- это j-й элемент массива, полученного преобразованием параметра x к типу T. Почему тип T описан именно таким образом? Что случится, если индексы массива - аргумента начинаются не с нуля? Ничего страшного не случится, тип индекса аргумента внутри процедуры совершенно не важен (и неизвестен), важно лишь, чтобы количество элементов аргумента не превысило 10922, так как в этом случае произойдет ошибка Range check error. Но таких массивов не бывает, так как (10922+1)*SizeOf(Real) = 10923*6 = 65538 - больше предельно допустимого размера массива.
Второй способ обработки нетипизированного параметра - совместить с ним по памяти какую-нибудь “обычную” переменную (скалярную или структурированную) и работать с этой переменной. Паскаль имеет специальное средство для совмещения по памяти - описатель Absolute , который применим не только к нетипизированным параметрам, но и к любым другим переменным. Описание совмещаемой переменной имеет вид:
Var имя : тип Absolute имя1;
Здесь имя - имя совмещаемой переменной, имя1 - имя некоторой другой переменной, которую мы назовем базовой, причем типы совмещаемой и базовой переменной могут быть совершенно разными. Компилятор не выделяет память для совмещаемой переменной, ее значение располагается там же, где и значение базовой переменной, точнее, у них одно и то же значение, которое интерпретируется по-разному в зависимости от их типа. Таким образом, любое изменение базовой переменной автоматически означает изменение совмещаемой переменной и наоборот. Приведем простой пример совмещения по памяти, забыв пока о нашей задаче.
Var a:LongInt;
b:Array[1..4] Of Byte Absolute a;
Begin
a:=-2;
WriteLn(‘Старший байт ‘,b[4],’ младший байт ‘,b[1]);
End.
Программа выведет “Старший байт 255 младший байт 254”. Число -2 кодируется в типе LongInt как 01111111 11111111 11111111 11111111 - младший бит нулевой, а все остальные биты единичные. Массив b занимает те же байты памяти, что и четырехбайтовое число a, значение элемента b[1] в двоичной кодировке равно 01111111 (биты записаны в последовательности от младшего к старшему), для типа Byte это число 254, элемент b[4] “владеет” восемью старшими битами - 11111111 - это число 255 для типа Byte.
Теперь вернемся к задаче о наименьшем элементе массива, используем в нашей процедуре описатель Absolute :
Procedure Minimum_3(n : Word; Var x; Var min : Real; Var index : Word);
Var j : Word;
y : Array[1..10922] Of Real Absolute x;
Begin
index:=1;
For j:=2 To n Do
If y[index]>y[j] Then index:=j;
min:=y[index];
End;