type
MyEnum = (w1,w2,w3,w4,w5);
Arr = array [1..10] of integer;
var
a1,a2: Arr;
b: array ['a'..'z',w2..w4] of string;
c: array [1..3] of array [1..4] of real;
Инициализация статического массива
При описании можно также задавать инициализацию массива значениями:
var
a: Arr := (1,2,3,4,5,6,7,8,9,0);
cc: array [1..3,1..4] of real := ((1,2,3,4), (5,6,7,8), (9,0,1,2));
Присваивание статического массива
Статические массивы одного типа можно присваивать друг другу, при этом будет производиться копирование содержимого одного массива в другой:
a1 := a2;
Вывод статического массива
Процедура write выводит статический массив, заключая элементы в квадратные скобки и разделяя их запятыми:
var a: Arr := (1,2,3,4,5,6,7,8,9,0);
var m := array [1..3,1..3] of integer := ((1,2,3),(4,5,6),(7,8,9));
writeln(a); // [1,2,3,4,5]
writeln(m); // [[1,2,3],[4,5,6],[7,8,9]]
Передача статического массива в подпрограмму
При передаче статического массива в подпрограмму по значению также производится копирование содержимого массива - фактического параметра в массив - формальный параметр:
procedure p(a: Arr); // передавать статический массив по значению - плохо!
...
p(a1);
Это крайне расточительно, поэтому статические массивы рекомендуется передавать по ссылке. Если массив не меняется внутри подпрограммы, то его следует передавать как ссылку на константу, если меняется - как ссылку на переменную:
type Arr = array [2..10] of integer;
procedure Squares(var a: Arr);
begin
for var i:= Low(a) to High(a) do
a[i] := Sqr(a[i]);
end;
procedure PrintArray(const a: Arr);
begin
for var i:= Low(a) to High(a) do
Print(a[i])
end;
var a: Arr := (1,3,5,7,9,2,4,6,8);
begin
Squares(a);
PrintArray(a);
end.
Для доступа к нижней и верхней границам размерности одномерного массива используются функции Low и High.
Динамические массивы
Описание динамического массива
Тип динамического массива конструируется следующим образом:
array of тип элементов (одномерный массив)
array [,] of тип элементов (двумерный массив)
и т.д.
Переменная типа динамический массив представляет собой ссылку. Поэтому динамический массив нуждается в инициализации (выделении памяти под элементы).
Выделение памяти под динамический массив
Для выделения памяти под динамический массив используется два способа. Первый способ использует операцию new в стиле вызова конструктора класса:
var
a: array of integer;
b: array [,] of real;
begin
a := new integer[5];
b := new real[4,3];
end.
Данный способ хорош тем, что позволяет совместить описание массива и выделение под него памяти:
var
a: array of integer := new integer[5];
b: array [,] of real := new real[4,3];
Описание типа можно при этом опускать - тип автовыводится:
var
a := new integer[5];
b := new real[4,3];
Второй способ выделения памяти под динамический массив использует стандартную процедуру SetLength:
SetLength(a,10);
SetLength(b,5,3);
Элементы массива при этом заполняются значениями по умолчанию.
Процедура SetLength обладает тем преимуществом, что при ее повторном вызове старое содержимое массива сохраняется.
Инициализация динамического массива
Можно инициализировать динамический массив при выделении под него память операцией new:
a := new integer[3](1,2,3);
b := new real[4,3] ((1,2,3),(4,5,6),(7,8,9),(0,1,2));
Инициализацию динамического массива в момент опеисания можно проводить в сокращенной форме:
var
a: array of integer := (1,2,3);
b: array [,] of real := ((1,2,3),(4,5,6),(7,8,9),(0,1,2));
c: array of array of integer := ((1,2,3),(4,5),(6,7,8));
При этом происходит выделение памяти под указанное справа количество элементов.
Инициализация одномерного массива проще всего осуществляется стандартными функциями Seq..., которые выделяют память нужного размера и заполняют массив указанными значениями:
var a := Arr(1,3,5,7,8); // array of integer
var s := Arr('Иванов','Петров','Сидоров'); // array of string
var b := ArrFill(777,5); // b = [777,777,777,777,777]
var r := ArrRandom(10); // заполнение 10 случайными целыми в диапазоне от 0 до 99
В таком же стиле можно инициализировать массивы массивов:
var a := Arr(Arr(1,3,5),Arr(7,8),Arr(5,6)); // array of array of integer
Длина динамического массива
Динамический массив помнит свою длину (n-мерный динамический массив помнит длину по каждой размерности). Длина массива (количество элементов в нем) возвращается стандартной функцией Length или свойством Length:
l := Length(a);
l := a.Length;
Для многомерных массивов длина по каждой размерности возвращается стандартной функцией Length с двумя параметрами или методом GetLength(i):
l := Length(a,0);
l := a.GetLength(0);
Ввод динамического массива
После выделения памяти ввод динамического массива можно осуществлять традиционно в цикле:
for var i:=0 to a.Length-1 do
read(a[i]);
Ввод динамического массива можно осуществлять с помощью стандартной функции ReadSeqInteger:
var a := ReadSeqInteger(10);
При этом под динамический массив выделяется память нужного размера.
Вывод динамического массива
Процедура write выводит динамический массив, заключая элементы в квадратные скобки и разделяя их запятыми:
var a := Arr(1,3,5,7,9);
writeln(a); // [1,3,5,7,9]
n-мерный динамический массив выводится так, что каждая размерность заключается в квадратные скобки:.
var m := new integer[3,3] ((1,2,3),(4,5,6),(7,8,9));
writeln(m); // [[1,2,3],[4,5,6],[7,8,9]]
Динамический массив можно выводить также методом расширения Print или Println:
a.Println;
При этом элементы по умолчанию разделяются пробелами, но можно это изменить, задав параметр Print, являющийся разделителем элементов. Например:
a.Print(NewLine);
выводит каждый элемент на отдельной строке.
Массивы массивов
Если объявлен массив массивов
var с: array of array of integer;
то его инициализацию можно провести только с помощью SetLength:
SetLength(с,5);
for i := 0 to 4 do
SetLength(c[i],3);
Для инициализации такого массива с помощью new следует ввести имя типа для array of integer:
type IntArray = array of integer;
var с: array of IntArray;
...
c := new IntArray[5];
for i := 0 to 4 do
c[i] := new integer[3];
Инициализацию массива массивов можно также проводить в сокращенной форме:
var
c: array of array of integer := ((1,2,3),(4,5),(6,7,8));
Присваивание динамических массивов
Динамические массивы одного типа можно присваивать друг другу, при этом обе переменные-ссылки будут указывать на одну память:
var a1: array of integer;
var a2: array of integer;
a1 := a2;
Следует обратить внимание, что для динамических массивов принята структурная эквивалентность типов: можно присваивать друг другу и передавать в качестве параметров подпрограмм динамические массивы, совпадающие по структуре.
Чтобы одному динамическому массиву присвоить копию другого массива, следует воспользоваться стандартной функцией Copy:
a1 := Copy(a2);
Передача динамического массива в подпрограмму
Динамический массив обычно передается в подпрограмму по значению, т.к. сама переменная уже является ссылкой:
procedure Squares(a: array of integer);
begin
for var i:=0 to a.Length-1 do
a[i] := Sqr(a[i]);
end;
begin
var a := Arr(1,3,5,7,9);
Squares(a);
end.
Динамический массив передается по ссылке только в одном случае: если он создается или пересоздается внутри подпрограммы. В частности, это необходимо делать если для динамического масива внутри подпрограммы вызывается SetLength:
procedure Add(var a: array of integer; x: integer);
begin
SetLength(a,a.Length+1);
a[a.Length-1] := x;
end;
begin
var a := Arr(1,3,5,7,9);
Add(a,666);
writeln(a);
end.
Стандартные процедуры и функции для работы с динамическими массивами
Методы расширения для динамических массивов
Указатели
Указатель - это ячейка памяти, хранящая адрес. В PascalABC.NET указатели делятся на типизированные (содержат адрес ячейки памяти данного типа) и бестиповые (содержат адрес оперативной памяти, не связанный с данными какого-либо определенного типа).
Тип указателя на тип T имеет форму ^T, например:
type pinteger = ^integer;