Динамические массивы

Описание динамического массива

Тип динамического массива конструируется следующим образом:

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.

Подпрограммы для работы с динамическими массивами

Подпрограммы для генерации динамических массивов

Методы расширения для последовательностей

Методы расширения для динамических массивов