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

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

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

array of тип элементов (одномерный массив)
array [,] of тип элементов (двумерный массив)
и т.д.

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

Выделение памяти под динамический массив

Для выделения памяти под динамический массив используется два способа. Первый способ использует операцию new в стиле вызова конструктора класса:

Данный способ хорош тем, что позволяет совместить описание массива и выделение под него памяти:

Второй способ выделения памяти под динамический массив использует стандартную процедуру SetLength :

Элементы массива при этом заполняются значениями по умолчанию.

Процедура SetLength обладает тем преимуществом, что при ее повторном вызове старое содержимое массива сохраняется.

Инициализация динамического массива

Можно инициализировать динамический массив при выделении под него память операцией new:

Инициализацию динамического массива в момент описания можно проводить в сокращенной форме:

При этом происходит выделение памяти под указанное справа количество элементов.

Инициализация одномерного массива проще всего осуществляется стандартными функциями 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 :

Для многомерных массивов длина по каждой размерности возвращается стандартной функцией Length с двумя параметрами или методом GetLength(i) :

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

После выделения памяти ввод динамического массива можно осуществлять традиционно в цикле:

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:

При этом элементы по умолчанию разделяются пробелами, но можно это изменить, задав параметр Print, являющийся разделителем элементов. Например:

выводит каждый элемент на отдельной строке.

Массивы массивов

Если объявлен массив массивов

то его инициализацию можно провести только с помощью SetLength :

Для инициализации такого массива с помощью 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];

Инициализацию массива массивов можно также проводить в сокращенной форме:

Присваивание динамических массивов

Динамические массивы одного типа можно присваивать друг другу, при этом обе переменные-ссылки будут указывать на одну память:

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

Чтобы одному динамическому массиву присвоить копию другого массива, следует воспользоваться стандартной функцией Copy :

Передача динамического массива в подпрограмму

Динамический массив обычно передается в подпрограмму по значению, т.к. сама переменная уже является ссылкой:

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.

Источник

Динамический или статический?

Традиционно в языке Паскаль используются статические массивы вида

Границы массива обязательно задаются константами, и изменить размер массива в ходе работы программы нельзя. Зато можно сделать индекс не только целого, но и, скажем, символьного или перечислимого типа. Например, для подсчета встречаемости каждой буквы можно использовать массив

и работать с ним в свое удовольствие:

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

В Delphi Object Pascal появились динамические массивы, размер которых можно не только задавать, но и менять по ходу работы программы. Именно об этих массивах и о преимуществах их использования пойдет речь далее.

Описываются они предельно просто:

Чтобы задать размер такого массива, следует вызвать процедуру SetLength:

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

Чтобы определить размер динамического массива, следует вызвать функцию Length: Length(a) возвращает размер динамического массива.

Динамические массивы представляются в памяти ссылками. Это означает, что любая переменная типа «динамический массив» является указателем на непрерывный участок динамической памяти. Первоначально этот указатель хранит nil, а вызов SetLength(a) выделяет под данные массива блок динамической памяти и записывает в a адрес этого блока памяти.

Во-вторых, при присваивании динамических массивов обе пременные b1 и b2 указывают на один участок динамической памяти, поэтому изменение элемента в массиве b1 приводит и к изменению массива b2:

Еще в Delphi имеются так называемые открытые массивы. К сожалению, они по внешнему виду очень похожи на динамические:

Смысл в том, что при вызове на место открытого массива можно подставлять статический массив любого размера. Но запись array of integer используется в совершенно другом смысле! Поэтому мы полностью отказались от открытых массивов в PascalABC.NET. Пользуйтесь динамическими массивами!

Посмотрим теперь, что нового появилось в динамических массивах в PascalABC.NET.

1. Динамические массивы можно инициализировать при описании:

2. Выделять память под динамическе массивовы можно с помощью операции new:

3. Как мы упомянули, динамический массив в PascalABC.NET является классом, а значит, он имеет методы и свойства:

5. Ввиду структурной эквивалентности типов для динамических массивов их можно передавать в подпрограмму следующим образом:

Напомним, что открытые массивы в PascalABC.NET отсутствуют!

6. Для динамических массивов (в отличие от статических) можно использовать цикл foreach (при условии, что мы осуществляем доступ к элементам только на чтение):

И, наконец, скажем несколько слов про двумерные динамические массивы. Они моделируются как массивы массивов.

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

Источник

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

Как создать одномерный динамический массив в Паскале?

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

Динамические массивы в Паскале не имеют заранее определенного размера.

Размер динамических массивов может изменяться.

Динамические массивы в Паскале пример

Пример создания динамического массива в Паскале:

здесь создан новый тип TIntMassiv, это динамический массив, его размер не известен, и переменная данного типа intMassiv.

Размер динамического массива неизвестен, но для работы с таким массивом размер надо установить. Устанавливают размер динамического массива в Паскаль с помощью функции SetLength

здесь установлен размер два для массива intMassiv.

Отсчет индексов динамического массива в Паскале всегда ведут с нуля.

Присвоим значение первому элементу массива intMassiv, а индекс первого элемента динамического массива всегда равен нулю:

Присвоим значение второму элементу массива intMassiv, а индекс второго элемента динамического массива всегда равен 1:

Изменим длину динамического массива в сторону увеличения:

здесь мы увеличили размер массива на один элемент, он добавился в конец существующего массива.

Присвоим значение новому третьему элементу массива intMassiv, а индекс третьего элемента динамического массива всегда равен 2:

Изменим длину динамического массива в сторону уменьшения:

здесь мы уменьшили размер массива на два элемента, при этом последние два элемента существующего массива удалились.

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

Источник

Занятие 5. Pascal abc.net: Динамические массивы

Объявление, выделение памяти

Обычно в языке Паскаль используются статические массивы вида:

var mas: array [1..10] of integer;

Границы статического массива изменить в ходе программы нельзя, так как они задаются в разделе объявлений «раз и навсегда».
Основным недостатком такого массива является то, что в случае, когда заранее не известно количество элементов массива, то приходится выделять память максимального размера, что называется «на всякий случай».

Рассмотрим работу с динамическим массивом.

Объявляется динамический массив в теле программы:

Или объявление с инициализацией:

А выделение памяти и размер такого массива задается уже по ходу программы:

var a: array of integer; var n:=readInteger; a:=new integer[n];

var a: array of integer; a:=new integer[readInteger];

var a: array of integer; var n:=readInteger; SetLength(a,n); // устанавливаем размер массива а

Ссылочная объектная модель: память выделяется служебным словом NEW

var a := new integer[5];

Организация памяти для массива a

Инициализация, присваивание и вывод

Возможна инициализация динамического массива при описании:

var a: array of integer := (1,2,3);

Новые способы заполнения массива (заполнители):

var a:=ArrFill(5,2); // 2 2 2 2 2

var a:=ReadArrInteger(5); var a:=ReadArrReal(5);

Заполнение случайными числами:

var a:=new integer[10]; a:=arrRandomInteger(10);

Или с разделителем между элементами:

Переприсваивание:

var a: array of integer := (1,2,3); var b:=a; // [1,2,3]

var a: array of integer := (1,2,3); var b:=a; b[2]:=1; print(a); //[1,2,1]

var a: array of integer := (1,2,3); var b:=Copy(a); b[2]:=1; print(a); //[1,2,3]

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

Если в программе случайно создается повторно один и тот же массив:

Но можно очистить память и принудительно:

В процессе очистки выполнение программы и всех процессов приостанавливается. По этой причине сборщик мусора в системах реального времени не используется.

Работа с элементами массива

for var i:=0 to High(a) do print(a[i]);;

foreach var x in a do print(x);

High(массив) — возвращает верхнюю границу динамического массива

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

Выполнение:
Выполним сначала БЕЗ использования обобщенной функции:

function IndexOf(a:array of integer;x:integer):integer; begin result:=-1; for var i:=0 to High(a) do if a[i]=x then begin result:=i; break end end; begin var a:=Arr(1,2,3,4,5); print(IndexOf(a,5)) end.

А теперь, выполним с использованием обобщенной функции:

При вызове обобщенной функции компиляция будет в два этапа:

Методы для работы с массивами

var a:=Arr(1,2,3,4,5); reverse(a); // [5,4,3,2,1]

var a:=Arr(2,3,1,4,5); //[1,2,3,4,5] sort(a);

Следующие методы не меняют сам массив:
a.Min
a.Max
a.Sum
a.Average — среднее арифметическое

Сдвиги

Стандартное выполнение:

var a:=Arr(1,2,3,4,5,6); var x:=a[0]; for var i:=0 to 4 do a[i]:=a[i+1]; a[5]:=x; print(a)

Срезы

var a:=Arr(1,2,3,4,5,6); print(a[1:5]) // [2,3,4,5]

a[1:5] — 1-й элемент включая, 5-й не включая

a[::-1] — получим 6 5 4 3 2 1

Т.о. выполнение при помощи срезов выглядит так:
Перестановка:

Т.е. создан еще массив уже со сдвигом.

Удаление и вставка элементов массива. Списки

Для расширения массива путем вставки какого-либо элемента, необходимо предусмотреть место в памяти. По этой причине для данных случаев проще использовать списки:
Списки — List — это тоже динамический массив, который может «расширяться» и «сужаться» по ходу программы (вставка и удаление элементов).
…

Решение задач

Простые задачи

Выполнение:

function SumArray(var a: array of integer): integer:=a.Sum; begin var a:=new integer[10]; a:=arrRandomInteger(10); foreach var x in a do print(x); println(‘длина массива = ‘,a.Length,’ сумма = ‘,ArraySum(a)) end.

Выполнение:
Дополните код:

Выполнение:

function MakeRandomRealArr (n : integer;a,b:real):array of real; begin var c:= ArrRandomReal(n,a,b); result:=c; end; begin var n:= readinteger; var a:=readReal; var b:=readReal; println(‘результат работы с функцией ‘,MakeRandomRealArr(n,a,b)); end.

Выполнение:

procedure SetToZeroOddIndexes(a: array of integer); begin var j:=0; while j FirstLocMin ).
Пояснение: локальным минимумом считается тот элемент, который меньше каждого из своих соседей. Считать, что локальный минимум в массиве есть. Первый и последний элемент в качестве локальных минимумов не рассматривать.

Задачи на срезы

Условный оператор не использовать.

Выполнение:

var n:=ReadInteger; var a:=ReadArrReal(n); var k:=ReadInteger; a[k-1 : : k].Print;

Условный оператор не использовать.

Условный оператор не использовать.

Условный оператор не использовать

Выполнение:

var n:=ReadInteger; var a:=ReadArrReal(n); var srez:=a[1::2]+a[::2]; Print(srez);

Условный оператор не использовать

Выполнение:

var n:=ReadInteger; var a:=ReadArrReal(n); var k:=ReadInteger; var l:=ReadInteger; var srez:=a[k-1:l].Average; print(srez);

Выполнение:

var n:=ReadInteger; var a:=ReadArrReal(n); print(a[1::2].min);

Источник

Открытые массивы

При описании открытого массива (в разделе type или var) указывается тип элементов, из которых он состоит (например, real, char и др.), но не указываются границы индексов. Например:

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

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

Чтобы в программе выделить память под открытый массив, следует воспользоваться процедурой setlength, которая принимает два фактических параметра – имя открытого массива и устанавливаемое количество элементов в нем. В результате работы setlength в памяти выделяется столько байт, сколько необходимо для хранения n-го количества элементов определенного типа. Так, если массив ранее описан как real и задано 5 элементов, то процедура setlength выделит под него 40 байт, т.к. для хранения каждого числа типа real требуется 8 байт памяти (хотя не обязательно 8, это может зависеть от компилятора).

Функция high принимает в качестве параметра имя массива и возвращает индексный номер последнего элемента массива. Например, выделяется память под десять элементов открытого массива; значит, индекс последнего будет равен 9 (т.к. индексация начинается с 0), что и вернет функция high.

Чтобы освободить, выделенную под массив память, используется оператор nil.

Обычно открытые массивы используются для передачи в подпрограмму массивов переменных размеров. Это позволяет с помощью одной и той же подпрограммы обрабатывать массивы произвольной длины. Без использования открытых массивов пришлось бы для каждого массива иной длины писать собственную подпрограмму.

Рассмотрите программу ниже и запустите ее на выполнение. Вам станет более понятно описанное выше.

Примечание. Функция sizeof возвращает количество памяти (в байтах), отведенное под переменную.

Источник